Getters

- **get_acceleration**(**self**) Returns the acceleration vector registered for an actor in that tick. - **Return:** _[carla.Vector3D](#carla.Vector3D) – m/s²_ - **get_angular_velocity**(**self**) Returns the angular velocity vector registered for an actor in that tick. - **Return:** _[carla.Vector3D](#carla.Vector3D) – rad/s_ - **get_transform**(**self**) Returns the actor's transform (location and rotation) for an actor in that tick. - **Return:** _[carla.Transform](#carla.Transform)_ - **get_velocity**(**self**) Returns the velocity vector registered for an actor in that tick. - **Return:** _[carla.Vector3D](#carla.Vector3D) – m/s_

carla.AttachmentType

Class that defines attachment options between an actor and its parent. When spawning actors, these can be attached to another actor so their position changes accordingly. This is specially useful for sensors. The snipet in carla.World.spawn_actor shows some sensors being attached to a car when spawned. Note that the attachment type is declared as an enum within the class.

Instance Variables

- **Rigid** With this fixed attatchment the object follow its parent position strictly. This is the recommended attachment to retrieve precise data from the simulation. - **SpringArm** An attachment that expands or retracts the position of the actor, depending on its parent. This attachment is only recommended to record videos from the simulation where a smooth movement is needed. SpringArms are an Unreal Engine component so [check the UE docs](https://docs.unrealengine.com/en-US/Gameplay/HowTo/UsingCameras/SpringArmComponents/index.html) to learn more about them.
Warning: The SpringArm attachment presents weird behaviors when an actor is spawned with a relative translation in the Z-axis (e.g. child_location = Location(0,0,2)).

carla.BlueprintLibrary

A class that contains the blueprints provided for actor spawning. Its main application is to return carla.ActorBlueprint objects needed to spawn actors. Each blueprint has an identifier and attributes that may or may not be modifiable. The library is automatically created by the server and can be accessed through carla.World.

Here is a reference containing every available blueprint and its specifics.

Methods

- **filter**(**self**, **wildcard_pattern**) Filters a list of blueprints matching the `wildcard_pattern` against the id and tags of every blueprint contained in this library and returns the result as a new one. Matching follows [fnmatch](https://docs.python.org/2/library/fnmatch.html) standard. - **Parameters:** - `wildcard_pattern` (_str_) - **Return:** _[carla.BlueprintLibrary](#carla.BlueprintLibrary)_ - **find**(**self**, **id**) Returns the blueprint corresponding to that identifier. - **Parameters:** - `id` (_str_) - **Return:** _[carla.ActorBlueprint](#carla.ActorBlueprint)_

Dunder methods

- **\__getitem__**(**self**, **pos**=int) Returns the blueprint stored in `pos` position inside the data structure containing them. - **Return:** _[carla.ActorBlueprint](#carla.ActorBlueprint)_ - **\__iter__**(**self**) Iterate over the [carla.ActorBlueprint](#carla.ActorBlueprint) stored in the library. - **\__len__**(**self**) Returns the amount of blueprints comprising the library. - **Return:** _int_ - **\__str__**(**self**) Parses the identifiers for every blueprint to string. - **Return:** _string_

carla.BoundingBox

Bounding boxes contain the geometry of an actor or an element in the scene. They can be used by carla.DebugHelper or a carla.Client to draw their shapes for debugging. Check out the snipet in carla.DebugHelper.draw_box where a snapshot of the world is used to draw bounding boxes for traffic lights.

Instance Variables

- **extent** (_[carla.Vector3D](#carla.Vector3D) – meters_) Vector from the center of the box to one vertex. The value in each axis equals half the size of the box for that axis. `extent.x * 2` would return the size of the box in the X-axis. - **location** (_[carla.Location](#carla.Location) – meters_) The center of the bounding box. - **rotation** (_[carla.Rotation](#carla.Rotation)_) The orientation of the bounding box.

Methods

- **\__init__**(**self**, **location**, **extent**) - **Parameters:** - `location` (_[carla.Location](#carla.Location)_) – Center of the box, relative to its parent. - `extent` (_[carla.Vector3D](#carla.Vector3D) – meters_) – Vector containing half the size of the box for every axis. - **contains**(**self**, **world_point**, **transform**) Returns **True** if a point passed in world space is inside this bounding box. - **Parameters:** - `world_point` (_[carla.Location](#carla.Location) – meters_) – The point in world space to be checked. - `transform` (_[carla.Transform](#carla.Transform)_) – Contains location and rotation needed to convert this object's local space to world space. - **Return:** _bool_

Getters

- **get_local_vertices**(**self**) Returns a list containing the locations of this object's vertices in local space. - **Return:** _list([carla.Location](#carla.Location))_ - **get_world_vertices**(**self**, **transform**) Returns a list containing the locations of this object's vertices in world space. - **Parameters:** - `transform` (_[carla.Transform](#carla.Transform)_) – Contains location and rotation needed to convert this object's local space to world space. - **Return:** _list([carla.Location](#carla.Location))_

Dunder methods

- **\__eq__**(**self**, **other**=[carla.BoundingBox](#carla.BoundingBox)) Returns true if both location and extent are equal for this and `other`. - **Return:** _bool_ - **\__ne__**(**self**, **other**=[carla.BoundingBox](#carla.BoundingBox)) Returns true if either location or extent are different for this and `other`. - **Return:** _bool_ - **\__str__**(**self**) Parses the location and extent of the bounding box to string. - **Return:** _str_

carla.CityObjectLabel

Enum declaration that contains the different tags available to filter the bounding boxes returned by carla.World.get_level_bbs(). These values correspond to the semantic tag that the elements in the scene have.

Instance Variables

- **None** - **Buildings** - **Fences** - **Other** - **Pedestrians** - **Poles** - **RoadLines** - **Roads** - **Sidewalks** - **TrafficSigns** - **Vegetation** - **Vehicles** - **Walls** - **Sky** - **Ground** - **Bridge** - **RailTrack** - **GuardRail** - **TrafficLight** - **Static** - **Dynamic** - **Water** - **Terrain**

carla.Client

The Client connects CARLA to the server which runs the simulation. Both server and client contain a CARLA library (libcarla) with some differences that allow communication between them. Many clients can be created and each of these will connect to the RPC server inside the simulation to send commands. The simulation runs server-side. Once the connection is established, the client will only receive data retrieved from the simulation. Walkers are the exception. The client is in charge of managing pedestrians so, if you are running a simulation with multiple clients, some issues may arise. For example, if you spawn walkers through different clients, collisions may happen, as each client is only aware of the ones it is in charge of.

The client also has a recording feature that saves all the information of a simulation while running it. This allows the server to replay it at will to obtain information and experiment with it. Here is some information about how to use this recorder.

Methods

- **\__init__**(**self**, **host**=127.0.0.1, **port**=2000, **worker_threads**=0)snipet → Client constructor. - **Parameters:** - `host` (_str_) – IP address where a CARLA Simulator instance is running. Default is localhost (127.0.0.1). - `port` (_int_) – TCP port where the CARLA Simulator instance is running. Default are 2000 and the subsequent 2001. - `worker_threads` (_int_) – Number of working threads used for background updates. If 0, use all available concurrency. - **apply_batch**(**self**, **commands**) Executes a list of commands on a single simulation step and retrieves no information. If you need information about the response of each command, use the __apply_batch_sync()__ method. [Here](10c5f6a482/PythonAPI/examples/spawn_npc.py (L126)) is an example on how to delete the actors that appear in [carla.ActorList](#carla.ActorList) all at once. - **Parameters:** - `commands` (_list_) – A list of commands to execute in batch. Each command is different and has its own parameters. They appear listed at the bottom of this page. - **apply_batch_sync**(**self**, **commands**, **due_tick_cue**=False)snipet → Executes a list of commands on a single simulation step, blocks until the commands are linked, and returns a list of command.Response that can be used to determine whether a single command succeeded or not. [Here](10c5f6a482/PythonAPI/examples/spawn_npc.py (L112-L116)) is an example of it being used to spawn actors. - **Parameters:** - `commands` (_list_) – A list of commands to execute in batch. The commands available are listed right above, in the method **apply_batch()**. - `due_tick_cue` (_bool_) – A boolean parameter to specify whether or not to perform a [carla.World.tick](#carla.World.tick) after applying the batch in _synchronous mode_. It is __False__ by default. - **Return:** _list(command.Response)_ - **generate_opendrive_world**(**self**, **opendrive**, **parameters**=(2.0, 50.0, 1.0, 0.6, true, true)) Loads a new world with a basic 3D topology generated from the content of an OpenDRIVE file. This content is passed as a `string` parameter. It is similar to `client.load_world(map_name)` but allows for custom OpenDRIVE maps in server side. Cars can drive around the map, but there are no graphics besides the road and sidewalks. - **Parameters:** - `opendrive` (_str_) – Content of an OpenDRIVE file as `string`, __not the path to the `.xodr`__. - `parameters` (_[carla.OpendriveGenerationParameters](#carla.OpendriveGenerationParameters)_) – Additional settings for the mesh generation. If none are provided, default values will be used. - **load_world**(**self**, **map_name**) Creates a new world with default settings using `map_name` map. All actors in the current world will be destroyed. - **Parameters:** - `map_name` (_str_) – Name of the map to be used in this world. Accepts both full paths and map names, e.g. '/Game/Carla/Maps/Town01' or 'Town01'. Remember that these paths are dynamic. - **reload_world**(**self**) Reload the current world, note that a new world is created with default settings using the same map. All actors present in the world will be destroyed, __but__ traffic manager instances will stay alive. - **Raises:** RuntimeError when corresponding. - **replay_file**(**self**, **name**, **start**, **duration**, **follow_id**) Load a new world with default settings using `map_name` map. All actors present in the current world will be destroyed, __but__ traffic manager instances will stay alive. - **Parameters:** - `name` (_str_) – Name of the file containing the information of the simulation. - `start` (_float – seconds_) – Time where to start playing the simulation. Negative is read as beginning from the end, being -10 just 10 seconds before the recording finished. - `duration` (_float – seconds_) – Time that will be reenacted using the information `name` file. If the end is reached, the simulation will continue. - `follow_id` (_int_) – ID of the actor to follow. If this is 0 then camera is disabled. - **show_recorder_actors_blocked**(**self**, **filename**, **min_time**, **min_distance**) The terminal will show the information registered for actors considered blocked. An actor is considered blocked when it does not move a minimum distance in a period of time, being these `min_distance` and `min_time`. - **Parameters:** - `filename` (_str_) – Name of the recorded file to load. - `min_time` (_float – seconds_) – Minimum time the actor has to move a minimum distance before being considered blocked. Default is 60 seconds. - `min_distance` (_float – centimeters_) – Minimum distance the actor has to move to not be considered blocked. Default is 100 centimeters. - **Return:** _string_ - **show_recorder_collisions**(**self**, **filename**, **category1**, **category2**) The terminal will show the collisions registered by the recorder. These can be filtered by specifying the type of actor involved. The categories will be specified in `category1` and `category2` as follows: 'h' = Hero, the one vehicle that can be controlled manually or managed by the user. 'v' = Vehicle 'w' = Walker 't' = Traffic light 'o' = Other 'a' = Any If you want to see only collisions between a vehicles and a walkers, use for `category1` as 'v' and `category2` as 'w' or vice versa. If you want to see all the collisions (filter off) you can use 'a' for both parameters. - **Parameters:** - `filename` (_str_) – Name or absolute path of the file recorded, depending on your previous choice. - `category1` (_single char_) – Character variable specifying a first type of actor involved in the collision. - `category2` (_single char_) – Character variable specifying the second type of actor involved in the collision. - **Return:** _string_ - **show_recorder_file_info**(**self**, **filename**, **show_all**) The information saved by the recorder will be parsed and shown in your terminal as text (frames, times, events, state, positions...). The information shown can be specified by using the `show_all` parameter. [Here](ref_recorder_binary_file_format.md) is some more information about how to read the recorder file. - **Parameters:** - `filename` (_str_) – Name or absolute path of the file recorded, depending on your previous choice. - `show_all` (_bool_) – If __True__, returns all the information stored for every frame (traffic light states, positions of all actors, orientation and animation data...). If __False__, returns a summary of key events and frames. - **Return:** _string_ - **start_recorder**(**self**, **filename**, **additional_data**=False) Enables the recording feature, which will start saving every information possible needed by the server to replay the simulation. - **Parameters:** - `filename` (_str_) – Name of the file to write the recorded data. A simple name will save the recording in 'CarlaUE4/Saved/recording.log'. Otherwise, if some folder appears in the name, it will be considered an absolute path. - `additional_data` (_bool_) – Enables or disable recording non-essential data for reproducing the simulation (bounding box location, physics control parameters, etc). - **stop_recorder**(**self**) Stops the recording in progress. If you specified a path in `filename`, the recording will be there. If not, look inside `CarlaUE4/Saved/`. - **stop_replayer**(**self**, **keep_actors**) Stop current replayer. - **Parameters:** - `keep_actors` (_bool_) – True if you want autoremove all actors from the replayer, or False to keep them.

Getters

- **get_available_maps**(**self**) Returns a list of strings containing the paths of the maps available on server. These paths are dynamic, they will be created during the simulation and so you will not find them when looking up in your files. One of the possible returns for this method would be: ['/Game/Carla/Maps/Town01', '/Game/Carla/Maps/Town02', '/Game/Carla/Maps/Town03', '/Game/Carla/Maps/Town04', '/Game/Carla/Maps/Town05', '/Game/Carla/Maps/Town06', '/Game/Carla/Maps/Town07']. - **Return:** _list(str)_ - **get_client_version**(**self**) Returns the client libcarla version by consulting it in the "Version.h" file. Both client and server can use different libcarla versions but some issues may arise regarding unexpected incompatibilities. - **Return:** _str_ - **get_server_version**(**self**) Returns the server libcarla version by consulting it in the "Version.h" file. Both client and server should use the same libcarla version. - **Return:** _str_ - **get_trafficmanager**(**self**, **client_connection**=8000) Returns an instance of the traffic manager related to the specified port. If it does not exist, this will be created. - **Parameters:** - `client_connection` (_int_) – Port that will be used by the traffic manager. Default is `8000`. - **Return:** _[carla.TrafficManager](#carla.TrafficManager)_ - **get_world**(**self**) Returns the world object currently active in the simulation. This world will be later used for example to load maps. - **Return:** _[carla.World](#carla.World)_

Setters

- **set_replayer_time_factor**(**self**, **time_factor**=1.0) When used, the time speed of the reenacted simulation is modified at will. It can be used several times while a playback is in curse. - **Parameters:** - `time_factor` (_float_) – 1.0 means normal time speed. Greater than 1.0 means fast motion (2.0 would be double speed) and lesser means slow motion (0.5 would be half speed). - **set_timeout**(**self**, **seconds**) Sets the maxixum time a network call is allowed before blocking it and raising a timeout exceeded error. - **Parameters:** - `seconds` (_float – seconds_) – New timeout value. Default is 5 seconds.

carla.CollisionEvent

Instance Variables

- **x** (_int_) X pixel coordinate. - **y** (_int_) Y pixel coordinate. - **t** (_int_) Timestamp of the moment the event happened. - **pol** (_bool_) Polarity of the event. __True__ for positive and __False__ for negative.

Dunder methods

- **\__getitem__**(**self**, **pos**=int) - **\__iter__**(**self**) Iterate over the [carla.Color](#carla.Color) that form the image. - **\__len__**(**self**) - **\__setitem__**(**self**, **pos**=int, **color**=[carla.Color](#carla.Color)) - **\__str__**(**self**)

carla.Junction

Class that embodies the intersections on the road described in the OpenDRIVE file according to OpenDRIVE 1.4 standards.

Instance Variables

- **id** (_int_) Identificator found in the OpenDRIVE file. - **bounding_box** (_[carla.BoundingBox](#carla.BoundingBox)_) Bounding box encapsulating the junction lanes.

Methods

Getters

- **get_waypoints**(**self**, **lane_type**) Returns a list of pairs of waypoints. Every tuple on the list contains first an initial and then a final waypoint within the intersection boundaries that describe the beginning and the end of said lane along the junction. Lanes follow their OpenDRIVE definitions so there may be many different tuples with the same starting waypoint due to possible deviations, as this are considered different lanes. - **Parameters:** - `lane_type` (_[carla.LaneType](#carla.LaneType)_) – Type of lanes to get the waypoints. - **Return:** _list(tuple([carla.Waypoint](#carla.Waypoint)))_

carla.LabelledPoint

Class that represent a position in space with a semantic label.

Instance Variables

- **location** Position in 3D space. - **label** Semantic tag of the point.

carla.Landmark

Class that defines any type of traffic landmark or sign affecting a road. These class mediates between the OpenDRIVE 1.4 standard definition of the landmarks and their representation in the simulation. This class retrieves all the information defining a landmark in OpenDRIVE and facilitates information about which lanes does it affect and when. Landmarks will be accessed by carla.Waypoint objects trying to retrieve the regulation of their lane. Therefore some attributes depend on the waypoint that is consulting the landmark and so, creating the object.

Instance Variables

- **road_id** (_int_) The OpenDRIVE ID of the road where this landmark is defined. Due to OpenDRIVE road definitions, this road may be different from the road the landmark is currently affecting. It is mostly the case in junctions where the road diverges in different routes. Example: a traffic light is defined in one of the divergent roads in a junction, but it affects all the possible routes. - **distance** (_float – meters_) Distance between the landmark and the waypoint creating the object (querying `get_landmarks` or `get_landmarks_of_type`). - **s** (_float – meters_) Distance where the landmark is positioned along the geometry of the road `road_id`. - **t** (_float – meters_) Lateral distance where the landmark is positioned from the edge of the road `road_id`. - **id** (_str_) Unique ID of the landmark in the OpenDRIVE file. - **name** (_str_) Name of the landmark in the in the OpenDRIVE file. - **is_dynamic** (_bool_) Indicates if the landmark has state changes over time such as traffic lights. - **orientation** (_[carla.LandmarkOrientation](#carla.LandmarkOrientation) – degrees_) Indicates which lanes the landmark is facing towards to. - **z_offset** (_float – meters_) Height where the landmark is placed. - **country** (_str_) Country code where the landmark is defined (default to OpenDRIVE is Germany 2017). - **type** (_str_) Type identificator of the landmark according to the country code. - **sub_type** (_str_) Subtype identificator of the landmark according to the country code. - **value** (_float_) Value printed in the signal (e.g. speed limit, maximum weight, etc). - **unit** (_str_) Units of measurement for the attribute `value`. - **height** (_float – meters_) Total height of the signal. - **width** (_float – meters_) Total width of the signal. - **text** (_str_) Additional text in the signal. - **h_offset** (_float – meters_) Orientation offset of the signal relative to the the definition of `road_id` at `s` in OpenDRIVE. - **pitch** (_float – meters_) Pitch rotation of the signal (Y-axis in [UE coordinates system](https://[carla.readthedocs.io](#carla.readthedocs.io)/en/latest/python_api/#carlarotation)). - **roll** (_float_) Roll rotation of the signal (X-axis in [UE coordinates system](https://[carla.readthedocs.io](#carla.readthedocs.io)/en/latest/python_api/#carlarotation)). - **waypoint** (_[carla.Waypoint](#carla.Waypoint)_) A waypoint placed in the lane of the one that made the query and at the `s` of the landmark. It is the first waypoint for which the landmark will be effective. - **transform** (_[carla.Transform](#carla.Transform)_) The location and orientation of the landmark in the simulation.

Methods

Getters

- **get_lane_validities**(**self**) Returns which lanes the landmark is affecting to. As there may be specific lanes where the landmark is not effective, the return is a list of pairs containing ranges of the __lane_id__ affected: Example: In a road with 5 lanes, being 3 not affected: [(from_lane1,to_lane2),(from_lane4,to_lane5)]. - **Return:** _list(tuple(int))_

carla.LandmarkOrientation

Helper class to define the orientation of a landmark in the road. The definition is not directly translated from OpenDRIVE but converted for the sake of understanding.

Instance Variables

- **Positive** The landmark faces towards vehicles going on the same direction as the road's geometry definition (lanes 0 and negative in OpenDRIVE). - **Negative** The landmark faces towards vehicles going on the opposite direction to the road's geometry definition (positive lanes in OpenDRIVE). - **Both** Affects vehicles going in both directions of the road.

carla.LandmarkType

Helper class containing a set of commonly used landmark types as defined by the default country code in the OpenDRIVE standard (Germany 2017). carla.Landmark does not reference this class. The landmark type is a string that varies greatly depending on the country code being used. This class only makes it easier to manage some of the most commonly used in the default set by describing them as an enum.

Instance Variables

- **Danger** Type 101. - **LanesMerging** Type 121. - **CautionPedestrian** Type 133. - **CautionBicycle** Type 138. - **LevelCrossing** Type 150. - **StopSign** Type 206. - **YieldSign** Type 205. - **MandatoryTurnDirection** Type 209. - **MandatoryLeftRightDirection** Type 211. - **TwoChoiceTurnDirection** Type 214. - **Roundabout** Type 215. - **PassRightLeft** Type 222. - **AccessForbidden** Type 250. - **AccessForbiddenMotorvehicles** Type 251. - **AccessForbiddenTrucks** Type 253. - **AccessForbiddenBicycle** Type 254. - **AccessForbiddenWeight** Type 263. - **AccessForbiddenWidth** Type 264. - **AccessForbiddenHeight** Type 265. - **AccessForbiddenWrongDirection** Type 267. - **ForbiddenUTurn** Type 272. - **MaximumSpeed** Type 274. - **ForbiddenOvertakingMotorvehicles** Type 276. - **ForbiddenOvertakingTrucks** Type 277. - **AbsoluteNoStop** Type 283. - **RestrictedStop** Type 286. - **HasWayNextIntersection** Type 301. - **PriorityWay** Type 306. - **PriorityWayEnd** Type 307. - **CityBegin** Type 310. - **CityEnd** Type 311. - **Highway** Type 330. - **RecomendedSpeed** Type 380. - **RecomendedSpeedEnd** Type 381.

Dunder methods

- **\__str__**(**self**)

carla.LidarMeasurement

Inherited from _[carla.SensorData](#carla.SensorData)_

Class that defines the LIDAR data retrieved by a sensor.lidar.ray_cast. This essentially simulates a rotating LIDAR using ray-casting. Learn more about this [here](ref_sensors.md#lidar-raycast-sensor).

Instance Variables

- **channels** (_int_) Number of lasers shot. - **horizontal_angle** (_float – radians_) Horizontal angle the LIDAR is rotated at the time of the measurement. - **raw_data** (_bytes_) Received list of 4D points. Each point consists of [x,y,z] coordiantes plus the intensity computed for that point.

Methods

- **save_to_disk**(**self**, **path**) Saves the point cloud to disk as a .ply file describing data from 3D scanners. The files generated are ready to be used within [MeshLab](http://www.meshlab.net/), an open source system for processing said files. Just take into account that axis may differ from Unreal Engine and so, need to be reallocated. - **Parameters:** - `path` (_str_)

Getters

- **get_point_count**(**self**, **channel**) Retrieves the number of points sorted by channel that are generated by this measure. Sorting by channel allows to identify the original channel for every point. - **Parameters:** - `channel` (_int_)

Dunder methods

- **\__getitem__**(**self**, **pos**=int) - **\__iter__**(**self**) Iterate over the [carla.LidarDetection](#carla.LidarDetection) retrieved as data. - **\__len__**(**self**) - **\__setitem__**(**self**, **pos**=int, **detection**=[carla.LidarDetection](#carla.LidarDetection)) - **\__str__**(**self**)

carla.Light

This class exposes the lights that exist in the scene, except for vehicle lights. The properties of a light can be queried and changed at will. Lights are automatically turned on when the simulator enters night mode (sun altitude is below zero).

Instance Variables

- **color** (_[carla.Color](#carla.Color)_) Color of the light. - **id** (_int_) Identifier of the light. - **intensity** (_float – lumens_) Intensity of the light. - **is_on** (_bool_) Switch of the light. It is __True__ when the light is on. When the night mode starts, this is set to __True__. - **location** (_[carla.Location](#carla.Location) – meters_) Position of the light. - **light_group** (_[carla.LightGroup](#carla.LightGroup)_) Group the light belongs to. - **light_state** (_[carla.LightState](#carla.LightState)_) State of the light. Summarizes its attributes, group, and if it is on/off.

Methods

- **turn_off**(**self**) Switches off the light. - **turn_on**(**self**) Switches on the light.

Setters

- **set_color**(**self**, **color**) Changes the color of the light to `color`. - **Parameters:** - `color` (_[carla.Color](#carla.Color)_) - **set_intensity**(**self**, **intensity**) Changes the intensity of the light to `intensity`. - **Parameters:** - `intensity` (_float – lumens_) - **set_light_group**(**self**, **light_group**) Changes the light to the group `light_group`. - **Parameters:** - `light_group` (_[carla.LightGroup](#carla.LightGroup)_) - **set_light_state**(**self**, **light_state**) Changes the state of the light to `light_state`. This may change attributes, group and turn the light on/off all at once. - **Parameters:** - `light_state` (_[carla.LightState](#carla.LightState)_)

carla.LightGroup

This class categorizes the lights on scene into different groups. These groups available are provided as a enum values that can be used as flags.

Note. So far, though there is a vehicle group, vehicle lights are not available as carla.Light objects. These have to be managed using carla.Vehicle and carla.VehicleLightState.

Instance Variables

- **None** All lights. - **Vehicle** - **Street** - **Building** - **Other**

carla.LightManager

This class handles the lights in the scene. Its main use is to get and set the state of groups or lists of lights in one call. An instance of this class can be retrieved by the carla.World.get_lightmanager().

Note. So far, though there is a vehicle group, vehicle lights are not available as carla.Light objects. These have to be managed using carla.Vehicle and carla.VehicleLightState.

Methods

- **is_active**(**self**, **lights**) Returns a list with booleans stating if the elements in `lights` are switched on/off. - **Parameters:** - `lights` (_list([carla.Light](#carla.Light))_) – List of lights to be queried. - **Return:** _list(bool)_ - **turn_off**(**self**, **lights**) Switches off all the lights in `lights`. - **Parameters:** - `lights` (_list([carla.Light](#carla.Light))_) – List of lights to be switched off. - **turn_on**(**self**, **lights**) Switches on all the lights in `lights`. - **Parameters:** - `lights` (_list([carla.Light](#carla.Light))_) – List of lights to be switched on.

Getters

- **get_all_lights**(**self**, **light_group**=[carla.LightGroup.None](#carla.LightGroup.None)) Returns a list containing the lights in a certain group. By default, the group is `None`. - **Parameters:** - `light_group` (_[carla.LightGroup](#carla.LightGroup)_) – Group to filter the lights returned. Default is `None`. - **Return:** _list([carla.Light](#carla.Light))_ - **get_color**(**self**, **lights**) Returns a list with the colors of every element in `lights`. - **Parameters:** - `lights` (_list([carla.Light](#carla.Light))_) – List of lights to be queried. - **Return:** _list([carla.Color](#carla.Color))_ - **Setter:** _[carla.LightManager.set_color](#carla.LightManager.set_color)_ - **get_intensity**(**self**, **lights**) Returns a list with the intensity of every element in `lights`. - **Parameters:** - `lights` (_list([carla.Light](#carla.Light))_) – List of lights to be queried. - **Return:** _list(float) – lumens_ - **Setter:** _[carla.LightManager.set_intensity](#carla.LightManager.set_intensity)_ - **get_light_group**(**self**, **lights**) Returns a list with the group of every element in `lights`. - **Parameters:** - `lights` (_list([carla.Light](#carla.Light))_) – List of lights to be queried. - **Return:** _list([carla.LightGroup](#carla.LightGroup))_ - **Setter:** _[carla.LightManager.set_light_group](#carla.LightManager.set_light_group)_ - **get_light_state**(**self**, **lights**) Returns a list with the state of all the attributes of every element in `lights`. - **Parameters:** - `lights` (_list([carla.Light](#carla.Light))_) – List of lights to be queried. - **Return:** _list([carla.LightState](#carla.LightState))_ - **Setter:** _[carla.LightManager.set_light_state](#carla.LightManager.set_light_state)_ - **get_turned_off_lights**(**self**, **light_group**) Returns a list containing lights switched off in the scene, filtered by group. - **Parameters:** - `light_group` (_[carla.LightGroup](#carla.LightGroup)_) – List of lights to be queried. - **Return:** _list([carla.Light](#carla.Light))_ - **get_turned_on_lights**(**self**, **light_group**) Returns a list containing lights switched on in the scene, filtered by group. - **Parameters:** - `light_group` (_[carla.LightGroup](#carla.LightGroup)_) – List of lights to be queried. - **Return:** _list([carla.Light](#carla.Light))_

Setters

- **set_active**(**self**, **lights**, **active**) Switches on/off the elements in `lights`. - **Parameters:** - `lights` (_list([carla.Light](#carla.Light))_) – List of lights to be switched on/off. - `active` (_list(bool)_) – List of booleans to be applied. - **set_color**(**self**, **lights**, **color**) Changes the color of the elements in `lights` to `color`. - **Parameters:** - `lights` (_list([carla.Light](#carla.Light))_) – List of lights to be changed. - `color` (_[carla.Color](#carla.Color)_) – Color to be applied. - **Getter:** _[carla.LightManager.get_color](#carla.LightManager.get_color)_ - **set_colors**(**self**, **lights**, **colors**) Changes the color of each element in `lights` to the corresponding in `colors`. - **Parameters:** - `lights` (_list([carla.Light](#carla.Light))_) – List of lights to be changed. - `colors` (_list([carla.Color](#carla.Color))_) – List of colors to be applied. - **set_intensities**(**self**, **lights**, **intensities**) Changes the intensity of each element in `lights` to the corresponding in `intensities`. - **Parameters:** - `lights` (_list([carla.Light](#carla.Light))_) – List of lights to be changed. - `intensities` (_list(float) – lumens_) – List of intensities to be applied. - **set_intensity**(**self**, **lights**, **intensity**) Changes the intensity of every element in `lights` to `intensity`. - **Parameters:** - `lights` (_list([carla.Light](#carla.Light))_) – List of lights to be changed. - `intensity` (_float – lumens_) – Intensity to be applied. - **Getter:** _[carla.LightManager.get_intensity](#carla.LightManager.get_intensity)_ - **set_light_group**(**self**, **lights**, **light_group**) Changes the group of every element in `lights` to `light_group`. - **Parameters:** - `lights` (_list([carla.Light](#carla.Light))_) – List of lights to be changed. - `light_group` (_[carla.LightGroup](#carla.LightGroup)_) – Group to be applied. - **Getter:** _[carla.LightManager.get_light_group](#carla.LightManager.get_light_group)_ - **set_light_groups**(**self**, **lights**, **light_groups**) Changes the group of each element in `lights` to the corresponding in `light_groups`. - **Parameters:** - `lights` (_list([carla.Light](#carla.Light))_) – List of lights to be changed. - `light_groups` (_list([carla.LightGroup](#carla.LightGroup))_) – List of groups to be applied. - **set_light_state**(**self**, **lights**, **light_state**) Changes the state of the attributes of every element in `lights` to `light_state`. - **Parameters:** - `lights` (_list([carla.Light](#carla.Light))_) – List of lights to be changed. - `light_state` (_[carla.LightState](#carla.LightState)_) – State of the attributes to be applied. - **Getter:** _[carla.LightManager.get_light_state](#carla.LightManager.get_light_state)_ - **set_light_states**(**self**, **lights**, **light_states**) Changes the state of the attributes of each element in `lights` to the corresponding in `light_states`. - **Parameters:** - `lights` (_list([carla.Light](#carla.Light))_) – List of lights to be changed. - `light_states` (_list([carla.LightState](#carla.LightState))_) – List of state of the attributes to be applied.

carla.LightState

This class represents all the light variables except the identifier and the location, which are should to be static. Using this class allows to manage all the parametrization of the light in one call.

Instance Variables

- **intensity** (_float – lumens_) Intensity of a light. - **color** (_[carla.Color](#carla.Color)_) Color of a light. - **group** (_[carla.LightGroup](#carla.LightGroup)_) Group a light belongs to. - **active** (_bool_) Switch of a light. It is __True__ when the light is on.

Methods

- **\__init__**(**self**, **intensity**=0.0, **color**=[carla.Color](#carla.Color)(), **group**=[carla.LightGroup.None](#carla.LightGroup.None), **active**=False) - **Parameters:** - `intensity` (_float – lumens_) – Intensity of the light. Default is `0.0`. - `color` (_[carla.Color](#carla.Color)_) – Color of the light. Default is black. - `group` (_[carla.LightGroup](#carla.LightGroup)_) – Group the light belongs to. Default is the generic group `None`. - `active` (_bool_) – Swith of the light. Default is `False`, light is off.

carla.Location

Inherited from _[carla.Vector3D](#carla.Vector3D)_

Represents a spot in the world.

Instance Variables

- **x** (_float – meters_) Distance from origin to spot on X axis. - **y** (_float – meters_) Distance from origin to spot on Y axis. - **z** (_float – meters_) Distance from origin to spot on Z axis.

Methods

- **\__init__**(**self**, **x**=0.0, **y**=0.0, **z**=0.0) - **Parameters:** - `x` (_float_) - `y` (_float_) - `z` (_float_) - **distance**(**self**, **location**) Returns Euclidean distance from this location to another one. - **Parameters:** - `location` (_[carla.Location](#carla.Location)_) – The other point to compute the distance with. - **Return:** _float – meters_

Dunder methods

- **\__eq__**(**self**, **other**=[carla.Location](#carla.Location)) Returns __True__ if both locations are the same point in space. - **Return:** _bool_ - **\__ne__**(**self**, **other**=[carla.Location](#carla.Location)) Returns __True__ if both locations are different points in space. - **Return:** _bool_ - **\__str__**(**self**) Parses the axis' values to string. - **Return:** _str_

carla.Map

Class containing the road information and waypoint managing. Data is retrieved from an OpenDRIVE file that describes the road. A query system is defined which works hand in hand with carla.Waypoint to translate geometrical information from the .xodr to natural world points. CARLA is currently working with OpenDRIVE 1.4 standard.

Instance Variables

- **name** (_str_) The name of the map. It corresponds to the .umap from Unreal Engine that is loaded from a CARLA server, which then references to the .xodr road description.

Methods

- **\__init__**(**self**, **name**, **xodr_content**) Constructor for this class. Though a map is automatically generated when initializing the world, using this method in no-rendering mode facilitates working with an .xodr without any CARLA server running. - **Parameters:** - `name` (_str_) – Name of the current map. - `xodr_content` (_str_) – .xodr content in string format. - **Return:** _list([carla.Transform](#carla.Transform))_ - **generate_waypoints**(**self**, **distance**) Returns a list of waypoints with a certain distance between them for every lane and centered inside of it. Waypoints are not listed in any particular order. Remember that waypoints closer than 2cm within the same road, section and lane will have the same identificator. - **Parameters:** - `distance` (_float – meters_) – Approximate distance between waypoints. - **Return:** _list([carla.Waypoint](#carla.Waypoint))_ - **save_to_disk**(**self**, **path**) Saves the .xodr OpenDRIVE file of the current map to disk. - **Parameters:** - `path` – Path where the file will be saved. - **to_opendrive**(**self**) Returns the .xodr OpenDRIVe file of the current map as string. - **Return:** _str_ - **transform_to_geolocation**(**self**, **location**) Converts a given `location`, a point in the simulation, to a [carla.GeoLocation](#carla.GeoLocation), which represents world coordinates. The geographical location of the map is defined inside OpenDRIVE within the tag . - **Parameters:** - `location` (_[carla.Location](#carla.Location)_) - **Return:** _[carla.GeoLocation](#carla.GeoLocation)_

Getters

- **get_all_landmarks**(**self**) Returns all the landmarks in the map. Landmarks retrieved using this method have a __null__ waypoint. - **Return:** _list([carla.Landmark](#carla.Landmark))_ - **get_all_landmarks_from_id**(**self**, **opendrive_id**) Returns the landmarks with a certain OpenDRIVE ID. Landmarks retrieved using this method have a __null__ waypoint. - **Parameters:** - `opendrive_id` (_string_) – The OpenDRIVE ID of the landmarks. - **Return:** _list([carla.Landmark](#carla.Landmark))_ - **get_all_landmarks_of_type**(**self**, **type**) Returns the landmarks of a specific type. Landmarks retrieved using this method have a __null__ waypoint. - **Parameters:** - `type` (_string_) – The type of the landmarks. - **Return:** _list([carla.Landmark](#carla.Landmark))_ - **get_landmark_group**(**self**, **landmark**) Returns the landmarks in the same group as the specified landmark (including itself). Returns an empty list if the landmark does not belong to any group. - **Parameters:** - `landmark` (_[carla.Landmark](#carla.Landmark)_) – A landmark that belongs to the group. - **Return:** _list([carla.Landmark](#carla.Landmark))_ - **get_spawn_points**(**self**) Returns a list of recommendations made by the creators of the map to be used as spawning points for the vehicles. The list includes [carla.Transform](#carla.Transform) objects with certain location and orientation. Said locations are slightly on-air in order to avoid Z-collisions, so vehicles fall for a bit before starting their way. - **Return:** _list([carla.Transform](#carla.Transform))_ - **get_topology**(**self**) Returns a list of tuples describing a minimal graph of the topology of the OpenDRIVE file. The tuples contain pairs of waypoints located either at the point a road begins or ends. The first one is the origin and the second one represents another road end that can be reached. This graph can be loaded into [NetworkX](https://networkx.github.io/) to work with. Output could look like this: [(w0, w1), (w0, w2), (w1, w3), (w2, w3), (w0, w4)]. - **Return:** _list(tuple([carla.Waypoint](#carla.Waypoint), [carla.Waypoint](#carla.Waypoint)))_ - **get_waypoint**(**self**, **location**, **project_to_road**=True, **lane_type**=[carla.LaneType.Driving](#carla.LaneType.Driving))snipet → Returns a waypoint that can be located in an exact location or translated to the center of the nearest lane. Said lane type can be defined using flags such as `LaneType.Driving & LaneType.Shoulder`. The method will return None if the waypoint is not found, which may happen only when trying to retrieve a waypoint for an exact location. That eases checking if a point is inside a certain road, as otherwise, it will return the corresponding waypoint. - **Parameters:** - `location` (_[carla.Location](#carla.Location) – meters_) – Location used as reference for the [carla.Waypoint](#carla.Waypoint). - `project_to_road` (_bool_) – If **True**, the waypoint will be at the center of the closest lane. This is the default setting. If **False**, the waypoint will be exactly in `location`. None means said location does not belong to a road. - `lane_type` (_[carla.LaneType](#carla.LaneType)_) – Limits the search for nearest lane to one or various lane types that can be flagged. - **Return:** _[carla.Waypoint](#carla.Waypoint)_ - **get_waypoint_xodr**(**self**, **road_id**, **lane_id**, **s**) Returns a waypoint if all the parameters passed are correct. Otherwise, returns __None__. - **Parameters:** - `road_id` (_int_) – ID of the road to get the waypoint. - `lane_id` (_int_) – ID of the lane to get the waypoint. - `s` (_float – meters_) – Specify the length from the road start. - **Return:** _[carla.Waypoint](#carla.Waypoint)_

Dunder methods

- **\__str__**(**self**)

carla.ObstacleDetectionEvent

Inherited from _[carla.SensorData](#carla.SensorData)_

Class that defines the obstacle data for sensor.other.obstacle. Learn more about this [here](ref_sensors.md#obstacle-detector).

Instance Variables

- **actor** (_[carla.Actor](#carla.Actor)_) The actor the sensor is attached to. - **other_actor** (_[carla.Actor](#carla.Actor)_) The actor or object considered to be an obstacle. - **distance** (_float – meters_) Distance between `actor` and `other`.

- **altitude** (_float – radians_) Altitude angle of the detection. - **azimuth** (_float – radians_) Azimuth angle of the detection. - **depth** (_float – meters_) Distance from the sensor to the detection position. - **velocity** (_float – m/s_) The velocity of the detected object towards the sensor.

Methods

Dunder methods

- **\__str__**(**self**)

carla.RadarMeasurement

Inherited from _[carla.SensorData](#carla.SensorData)_

Class that defines and gathers the measures registered by a sensor.other.radar, representing a wall of points in front of the sensor with a distance, angle and velocity in relation to it. The data consists of a [carla.RadarDetection](#carla.RadarDetection) array. Learn more about this [here](ref_sensors.md#radar-sensor).

Instance Variables

- **raw_data** (_bytes_) The complete information of the [carla.RadarDetection](#carla.RadarDetection) the radar has registered.

Methods

Getters

- **get_detection_count**(**self**) Retrieves the number of entries generated, same as **\__str__()**.

Dunder methods

- **\__getitem__**(**self**, **pos**=int) - **\__iter__**(**self**) Iterate over the [carla.RadarDetection](#carla.RadarDetection) retrieved as data. - **\__len__**(**self**) - **\__setitem__**(**self**, **pos**=int, **detection**=[carla.RadarDetection](#carla.RadarDetection)) - **\__str__**(**self**)

carla.Rotation

Class that represents a 3D rotation and therefore, an orientation in space. CARLA uses the Unreal Engine coordinates system. This is a Z-up left-handed system.

The constructor method follows a specific order of declaration: (pitch, yaw, roll), which corresponds to (Y-rotation,Z-rotation,X-rotation).

Unreal Engine's coordinates system.

Instance Variables

- **pitch** (_float – degrees_) Y-axis rotation angle. - **yaw** (_float – degrees_) Z-axis rotation angle. - **roll** (_float – degrees_) X-axis rotation angle.

Methods

- **\__init__**(**self**, **pitch**=0.0, **yaw**=0.0, **roll**=0.0) - **Parameters:** - `pitch` (_float – degrees_) – Y-axis rotation angle. - `yaw` (_float – degrees_) – Z-axis rotation angle. - `roll` (_float – degrees_) – X-axis rotation angle. - **Warning:** _The declaration order is different in CARLA (pitch,yaw,roll), and in the Unreal Engine Editor (roll,pitch,yaw). When working in a build from source, don't mix up the axes' rotations._

Getters

carla.RssResponse

Inherited from _[carla.SensorData](#carla.SensorData)_

Class that contains the output of a [carla.RssSensor](#carla.RssSensor). This is the result of the RSS calculations performed for the parent vehicle of the sensor.

A carla.RssRestrictor will use the data to modify the carla.VehicleControl of the vehicle.

Instance Variables

- **response_valid** (_bool_) States if the response is valid. It is __False__ if calculations failed or an exception occured. - **proper_response** (_ad.rss.state.ProperResponse_) The proper response that the RSS calculated for the vehicle. - **rss_state_snapshot** (_ad.rss.state.RssStateSnapshot_) Detailed RSS states at the current moment in time. - **ego_dynamics_on_route** (_[carla.RssEgoDynamicsOnRoute](#carla.RssEgoDynamicsOnRoute)_) Current ego vehicle dynamics regarding the route. - **world_model** (_ad.rss.world.WorldModel_) World model used for calculations. - **situation_snapshot** (_ad.rss.situation.SituationSnapshot_) Detailed RSS situations extracted from the world model.

Methods

Dunder methods

- **\__str__**(**self**)

carla.RssRestrictor

These objects apply restrictions to a carla.VehicleControl. It is part of the CARLA implementation of the C++ Library for Responsibility Sensitive Safety. This class works hand in hand with a rss sensor, which provides the data of the restrictions to be applied.

Methods

- **restrict_vehicle_control**(**self**, **vehicle_control**, **proper_response**, **ego_dynamics_on_route**, **vehicle_physics**) Applies the safety restrictions given by a [carla.RssSensor](#carla.RssSensor) to a [carla.VehicleControl](#carla.VehicleControl). - **Parameters:** - `vehicle_control` (_[carla.VehicleControl](#carla.VehicleControl)_) – The input vehicle control to be restricted. - `proper_response` (_ad.rss.state.ProperResponse_) – Part of the response generated by the sensor. Contains restrictions to be applied to the acceleration of the vehicle. - `ego_dynamics_on_route` (_[carla.RssEgoDynamicsOnRoute](#carla.RssEgoDynamicsOnRoute)_) – Part of the response generated by the sensor. Contains dynamics and heading of the vehicle regarding its route. - `vehicle_physics` (_[carla.VehiclePhysicsControl](#carla.VehiclePhysicsControl)_) – The current physics of the vehicle. Used to apply the restrictions properly. - **Return:** _[carla.VehicleControl](#carla.VehicleControl)_

carla.RssRoadBoundariesMode

Enum declaration used in carla.RssSensor to enable or disable the stay on road feature. In summary, this feature considers the road boundaries as virtual objects. The minimum safety distance check is applied to these virtual walls, in order to make sure the vehicle does not drive off the road.

Instance Variables

- **On** Enables the _stay on road_ feature. - **Off** Disables the _stay on road_ feature.

carla.RssSensor

Inherited from _[carla.Sensor](#carla.Sensor)_

This sensor works a bit differently than the rest. Take look at the [specific documentation](adv_rss.md), and the [rss sensor reference](ref_sensors.md#rss-sensor) to gain full understanding of it.

The RSS sensor uses world information, and a RSS library to make safety checks on a vehicle. The output retrieved by the sensor is a carla.RssResponse. This will be used by a carla.RssRestrictor to modify a carla.VehicleControl before applying it to a vehicle.

Instance Variables

- **ego_vehicle_dynamics** (_ad.rss.world.RssDynamics_) States the [RSS parameters](https://intel.github.io/ad-rss-lib/ad_rss/Appendix-ParameterDiscussion/) that the sensor will consider for the ego vehicle if no actor constellation callback is registered. - **other_vehicle_dynamics** (_ad.rss.world.RssDynamics_) States the [RSS parameters](https://intel.github.io/ad-rss-lib/ad_rss/Appendix-ParameterDiscussion/) that the sensor will consider for the rest of vehicles if no actor constellation callback is registered. - **pedestrian_dynamics** (_ad.rss.world.RssDynamics_) States the [RSS parameters](https://intel.github.io/ad-rss-lib/ad_rss/Appendix-ParameterDiscussion/) that the sensor will consider for pedestrians if no actor constellation callback is registered. - **road_boundaries_mode** (_[carla.RssRoadBoundariesMode](#carla.RssRoadBoundariesMode)_) Switches the [stay on road](https://intel.github.io/ad-rss-lib/ad_rss_map_integration/HandleRoadBoundaries/) feature. By default is __Off__. - **routing_targets** (_vector<[carla.Transform](#carla.Transform)>_) The current list of targets considered to route the vehicle. If no routing targets are defined, a route is generated at random.

Methods

- **append_routing_target**(**self**, **routing_target**) Appends a new target position to the current route of the vehicle. - **Parameters:** - `routing_target` (_[carla.Transform](#carla.Transform)_) – New target point for the route. Choose these after the intersections to force the route to take the desired turn. - **drop_route**(**self**) Discards the current route. If there are targets remaining in **routing_targets**, creates a new route using those. Otherwise, a new route is created at random. - **register_actor_constellation_callback**(**self**, **callback**) Register a callback to customize a [carla.RssActorConstellationResult](#carla.RssActorConstellationResult). By this callback the settings of RSS parameters are done per actor constellation and the settings (ego_vehicle_dynamics, other_vehicle_dynamics and pedestrian_dynamics) have no effect. - **Parameters:** - `callback` – The function to be called whenever a RSS situation is about to be calculated. - **reset_routing_targets**(**self**) Erases the targets that have been appended to the route.

Setters

- **set_log_level**(**self**, **log_level**) Sets the log level. - **Parameters:** - `log_level` (_[carla.RssLogLevel](#carla.RssLogLevel)_) – New log level. - **set_map_log_level**(**self**, **log_level**) Sets the map log level. - **Parameters:** - `log_level` (_[carla.RssLogLevel](#carla.RssLogLevel)_) – New map log level.

Dunder methods

- **\__str__**(**self**)

carla.SemanticLidarDetection

Data contained inside a carla.SemanticLidarMeasurement. Each of these represents one of the points in the cloud with its location, the cosine of the incident angle, index of the object hit, and its semantic tag.

Instance Variables

- **point** (_[carla.Location](#carla.Location) – meters_) [x,y,z] coordinates of the point. - **cos_inc_angle** (_float_) Cosine of the incident angle between the ray, and the normal of the hit object. - **object_idx** (_uint_) ID of the actor hit by the ray. - **object_tag** (_uint_) [Semantic tag](https://[carla.readthedocs.io](#carla.readthedocs.io)/en/latest/ref_sensors/#semantic-segmentation-camera) of the component hit by the ray.

Methods

Dunder methods

- **\__str__**(**self**)

carla.SemanticLidarMeasurement

Inherited from _[carla.SensorData](#carla.SensorData)_

Class that defines the semantic LIDAR data retrieved by a sensor.lidar.ray_cast_semantic. This essentially simulates a rotating LIDAR using ray-casting. Learn more about this [here](ref_sensors.md#semanticlidar-raycast-sensor).

Instance Variables

- **channels** (_int_) Number of lasers shot. - **horizontal_angle** (_float – radians_) Horizontal angle the LIDAR is rotated at the time of the measurement. - **raw_data** (_bytes_) Received list of raw detection points. Each point consists of [x,y,z] coordinates plus the cosine of the incident angle, the index of the hit actor, and its semantic tag.

Methods

- **save_to_disk**(**self**, **path**) Saves the point cloud to disk as a .ply file describing data from 3D scanners. The files generated are ready to be used within [MeshLab](http://www.meshlab.net/), an open-source system for processing said files. Just take into account that axis may differ from Unreal Engine and so, need to be reallocated. - **Parameters:** - `path` (_str_)

Getters

Dunder methods

- **\__getitem__**(**self**, **pos**=int) - **\__iter__**(**self**) Iterate over the [carla.SemanticLidarDetection](#carla.SemanticLidarDetection) retrieved as data. - **\__len__**(**self**) - **\__setitem__**(**self**, **pos**=int, **detection**=[carla.SemanticLidarDetection](#carla.SemanticLidarDetection)) - **\__str__**(**self**)

carla.Sensor

Inherited from _[carla.Actor](#carla.Actor)_

Sensors compound a specific family of actors quite diverse and unique. They are normally spawned as attachment/sons of a vehicle (take a look at [carla.World](#carla.World) to learn about actor spawning). Sensors are thoroughly designed to retrieve different types of data that they are listening to. The data they receive is shaped as different subclasses inherited from [carla.SensorData](#carla.SensorData) (depending on the sensor).

Most sensors can be divided in two groups: those receiving data on every tick (cameras, point clouds and some specific sensors) and those who only receive under certain circumstances (trigger detectors). CARLA provides a specific set of sensors and their blueprint can be found in carla.BlueprintLibrary. All the information on their preferences and settlement can be found here, but the list of those available in CARLA so far goes as follow.
Receive data on every tick.

Depth camera.
Gnss sensor.
IMU sensor.
Lidar raycast.
SemanticLidar raycast.
Radar.
RGB camera.
RSS sensor.
Semantic Segmentation camera.
Only receive data when triggered.
Collision detector.
Lane invasion detector.
Obstacle detector.

Instance Variables

- **is_listening** (_boolean_) When True the sensor will be waiting for data.

Methods

- **listen**(**self**, **callback**)snipet → The function the sensor will be calling to every time a new measurement is received. This function needs for an argument containing an object type [carla.SensorData](#carla.SensorData) to work with. - **Parameters:** - `callback` (_function_) – The called function with one argument containing the sensor data. - **stop**(**self**) Commands the sensor to stop listening for data.

Dunder methods

- **\__str__**(**self**)

carla.SensorData

Base class for all the objects containing data generated by a carla.Sensor. This objects should be the argument of the function said sensor is listening to, in order to work with them. Each of these sensors needs for a specific type of sensor data. Hereunder is a list of the sensors and their corresponding data.

Cameras (RGB, depth and semantic segmentation): carla.Image.
Collision detector: carla.CollisionEvent.
GNSS sensor: carla.GnssMeasurement.
IMU sensor: carla.IMUMeasurement.
Lane invasion detector: carla.LaneInvasionEvent.
LIDAR sensor: carla.LidarMeasurement.
Obstacle detector: carla.ObstacleDetectionEvent.
Radar sensor: carla.RadarMeasurement.
RSS sensor: carla.RssResponse.
Semantic LIDAR sensor: carla.SemanticLidarMeasurement.

Getters

- **get_port**(**self**) Returns the port where the Traffic Manager is connected. If the object is a TM-Client, it will return the port of its TM-Server. Read the [documentation](#adv_traffic_manager.md#multiclient-and-multitm-management) to learn the difference. - **Return:** _uint16_

Setters

- **set_global_distance_to_leading_vehicle**(**self**, **distance**) Sets the minimum distance in meters that vehicles have to keep with the rest. The distance is in meters and will affect the minimum moving distance. It is computed from center to center of the vehicle objects. - **Parameters:** - `distance` (_float – meters_) – Meters between vehicles. - **set_hybrid_mode_radius**(**self**, **r**=70.0) With hybrid physics on, changes the radius of the area of influence where physics are enabled. - **Parameters:** - `r` (_float – meters_) – New radius where physics are enabled. - **set_hybrid_physics_mode**(**self**, **enabled**=False) Enables or disables the hybrid physics mode. In this mode, vehicle's farther than a certain radius from the ego vehicle will have their physics disabled. Computation cost will be reduced by not calculating vehicle dynamics. Vehicles will be teleported. - **Parameters:** - `enabled` (_bool_) – If __True__, enables the hybrid physics. - **set_osm_mode**(**self**, **mode_switch**=True) Enables or disables the OSM mode. This mode allows the user to run TM in a map created with the [OSM feature](tuto_G_openstreetmap.md). These maps allow having dead-end streets. Normally, if vehicles cannot find the next waypoint, TM crashes. If OSM mode is enabled, it will show a warning, and destroy vehicles when necessary. - **Parameters:** - `mode_switch` (_bool_) – If __True__, the OSM mode is enabled. - **set_percentage_keep_right_rule**(**self**, **actor**, **perc**) During the localization stage, this method sets a percent chance that vehicle will follow the *keep right* rule, and stay in the right lane. - **Parameters:** - `actor` (_[carla.Actor](#carla.Actor)_) – Vehicle whose behaviour is being changed. - `perc` (_float_) – Between 0 and 100. Amount of times the vehicle will follow the keep right rule. - **set_random_device_seed**(**self**, **value**) Sets a specific random seed for the Traffic Manager, thereby setting it to be deterministic. - **Parameters:** - `value` (_int_) – Seed value for the random number generation of the Traffic Manager. - **set_synchronous_mode**(**self**, **mode_switch**=True) Sets the Traffic Manager to [synchronous mode](adv_traffic_manager.md#synchronous-mode). In a [multiclient situation](adv_traffic_manager.md#multiclient), only the TM-Server can tick. Similarly, in a [multiTM situation](adv_traffic_manager.md#multitm), only one TM-Server must tick. Use this method in the client that does the world tick, and right after setting the world to synchronous mode, to set which TM will be the master while in sync. - **Parameters:** - `mode_switch` (_bool_) – If __True__, the TM synchronous mode is enabled. - **Warning:** _If the server is set to synchronous mode, the TM must be set to synchronous mode too in the same client that does the tick. _

carla.TrafficSign

Inherited from _[carla.Actor](#carla.Actor)_

This class inherits from the [carla.Actor](#carla.Actor) and defines pedestrians in the simulation. Walkers are a special type of actor that can be controlled either by an AI ([carla.WalkerAIController](#carla.WalkerAIController)) or manually via script, using a series of [carla.WalkerControl](#carla.WalkerControl) to move these and their skeletons.

Instance Variables

- **bounding_box** (_[carla.BoundingBox](#carla.BoundingBox)_) Bounding box containing the geometry of the walker. Its location and rotation are relative to the walker it is attached to.

Methods

- **apply_control**(**self**, **control**) On the next tick, the control will move the walker in a certain direction with a certain speed. Jumps can be commanded too. - **Parameters:** - `control` (_[carla.WalkerControl](#carla.WalkerControl)_) - **apply_control**(**self**, **control**) On the next tick, the control defines a list of bone transformations that will be applied to the walker's skeleton. - **Parameters:** - `control` (_[carla.WalkerBoneControl](#carla.WalkerBoneControl)_)

Getters

- **get_control**(**self**) The client returns the control applied to this walker during last tick. The method does not call the simulator. - **Return:** _[carla.WalkerControl](#carla.WalkerControl)_

Dunder methods

- **\__str__**(**self**)

carla.WalkerAIController

Inherited from _[carla.Actor](#carla.Actor)_

Class that conducts AI control for a walker. The controllers are defined as actors, but they are quite different from the rest. They need to be attached to a parent actor during their creation, which is the walker they will be controlling (take a look at [carla.World](#carla.World) if you are yet to learn on how to spawn actors). They also need for a special blueprint (already defined in [carla.BlueprintLibrary](#carla.BlueprintLibrary) as "controller.ai.walker"). This is an empty blueprint, as the AI controller will be invisible in the simulation but will follow its parent around to dictate every step of the way.

Methods

- **go_to_location**(**self**, **destination**) Sets the destination that the pedestrian will reach. - **Parameters:** - `destination` (_[carla.Location](#carla.Location) – meters_) - **start**(**self**) Enables AI control for its parent walker. - **stop**(**self**)snipet → Disables AI control for its parent walker.

Setters

- **set_max_speed**(**self**, **speed**=1.4) Sets a speed for the walker in meters per second. - **Parameters:** - `speed` (_float – m/s_) – An easy walking speed is set by default.

Dunder methods

- **\__str__**(**self**)

carla.WalkerBoneControl

This class grants bone specific manipulation for walker. The skeletons of walkers have been unified for clarity and the transform applied to each bone are always relative to its parent. Take a look here to learn more on how to create a walker and define its movement.

Instance Variables

- **bone_transforms** (_list([name,transform])_) List of tuples where the first value is the bone's name and the second value stores the transformation (changes in location and rotation) that will be applied to it.

Methods

- **\__init__**(**self**, **list(name,transform)**) Initializes an object containing moves to be applied on tick. These are listed with the name of the bone and the transform that will be applied to it. - **Parameters:** - `list(name,transform)` (_tuple_)

Dunder methods

- **\__str__**(**self**)

carla.WalkerControl

Methods

- **\__init__**(**self**, **actor**, **force**) - **Parameters:** - `actor` (_[carla.Actor](#carla.Actor) or int_) – Actor or its ID to whom the command will be applied to. - `force` (_[carla.Vector3D](#carla.Vector3D) – N_)

command.ApplyImpulse

Command adaptation of add_impulse() in carla.Actor. Applies an impulse to an actor.

Instance Variables

- **actor_id** (_int_) Actor affected by the command. - **impulse** (_[carla.Vector3D](#carla.Vector3D) – N*s_) Impulse applied to the actor.

Snipet for carla.ActorBlueprint.set_attribute

  

# This recipe changes attributes of different type of blueprint actors.

# ...
walker_bp = world.get_blueprint_library().filter('walker.pedestrian.0002')
walker_bp.set_attribute('is_invincible', True)

# ...
# Changes attribute randomly by the recommended value
vehicle_bp = wolrd.get_blueprint_library().filter('vehicle.bmw.*')
color = random.choice(vehicle_bp.get_attribute('color').recommended_values)
vehicle_bp.set_attribute('color', color)

# ...

camera_bp = world.get_blueprint_library().filter('sensor.camera.rgb')
camera_bp.set_attribute('image_size_x', 600)
camera_bp.set_attribute('image_size_y', 600)
# ...

Copy snipet Close snipet

Snipet for carla.Client.apply_batch_sync

  
# 0. Choose a blueprint fo the walkers
world = client.get_world()
blueprintsWalkers = world.get_blueprint_library().filter("walker.pedestrian.*")
walker_bp = random.choice(blueprintsWalkers)

# 1. Take all the random locations to spawn
spawn_points = []
for i in range(50):
    spawn_point = carla.Transform()
    spawn_point.location = world.get_random_location_from_navigation()
    if (spawn_point.location != None):
        spawn_points.append(spawn_point)

# 2. Build the batch of commands to spawn the pedestrians
batch = []
for spawn_point in spawn_points:
    walker_bp = random.choice(blueprintsWalkers)
    batch.append(carla.command.SpawnActor(walker_bp, spawn_point))

# 2.1 apply the batch
results = client.apply_batch_sync(batch, True)
for i in range(len(results)):
    if results[i].error:
        logging.error(results[i].error)
    else:
        walkers_list.append({"id": results[i].actor_id})

# 3. Spawn walker AI controllers for each walker
batch = []
walker_controller_bp = world.get_blueprint_library().find('controller.ai.walker')
for i in range(len(walkers_list)):
    batch.append(carla.command.SpawnActor(walker_controller_bp, carla.Transform(), walkers_list[i]["id"]))

# 3.1 apply the batch
results = client.apply_batch_sync(batch, True)
for i in range(len(results)):
    if results[i].error:
        logging.error(results[i].error)
    else:
        walkers_list[i]["con"] = results[i].actor_id

# 4. Put altogether the walker and controller ids
for i in range(len(walkers_list)):
    all_id.append(walkers_list[i]["con"])
    all_id.append(walkers_list[i]["id"])
all_actors = world.get_actors(all_id)

# wait for a tick to ensure client receives the last transform of the walkers we have just created
world.wait_for_tick()

# 5. initialize each controller and set target to walk to (list is [controller, actor, controller, actor ...])
for i in range(0, len(all_actors), 2):
    # start walker
    all_actors[i].start()
    # set walk to random point
    all_actors[i].go_to_location(world.get_random_location_from_navigation())
    # random max speed
    all_actors[i].set_max_speed(1 + random.random())    # max speed between 1 and 2 (default is 1.4 m/s)

Copy snipet Close snipet

Snipet for carla.WalkerAIController.stop

  

#To destroy the pedestrians, stop them from the navigation, and then destroy the objects (actor and controller).

# stop pedestrians (list is [controller, actor, controller, actor ...])
for i in range(0, len(all_id), 2):
    all_actors[i].stop()

# destroy pedestrian (actor and controller)
client.apply_batch([carla.command.DestroyActor(x) for x in all_id])

Copy snipet Close snipet

Snipet for carla.Map.get_waypoint

  

# This recipe shows the current traffic rules affecting the vehicle. 
# Shows the current lane type and if a lane change can be done in the actual lane or the surrounding ones.

# ...
waypoint = world.get_map().get_waypoint(vehicle.get_location(),project_to_road=True, lane_type=(carla.LaneType.Driving | carla.LaneType.Shoulder | carla.LaneType.Sidewalk))
print("Current lane type: " + str(waypoint.lane_type))
# Check current lane change allowed
print("Current Lane change:  " + str(waypoint.lane_change))
# Left and Right lane markings
print("L lane marking type: " + str(waypoint.left_lane_marking.type))
print("L lane marking change: " + str(waypoint.left_lane_marking.lane_change))
print("R lane marking type: " + str(waypoint.right_lane_marking.type))
print("R lane marking change: " + str(waypoint.right_lane_marking.lane_change))
# ...

Copy snipet Close snipet

Snipet for carla.DebugHelper.draw_line

  

# This recipe is a modification of lane_explorer.py example.
# It draws the path of an actor through the world, printing information at each waypoint.

# ...
current_w = map.get_waypoint(vehicle.get_location())
while True:

    next_w = map.get_waypoint(vehicle.get_location(), lane_type=carla.LaneType.Driving | carla.LaneType.Shoulder | carla.LaneType.Sidewalk )
    # Check if the vehicle is moving
    if next_w.id != current_w.id:
        vector = vehicle.get_velocity()
        # Check if the vehicle is on a sidewalk
        if current_w.lane_type == carla.LaneType.Sidewalk:
            draw_waypoint_union(debug, current_w, next_w, cyan if current_w.is_junction else red, 60)
        else:
            draw_waypoint_union(debug, current_w, next_w, cyan if current_w.is_junction else green, 60)
        debug.draw_string(current_w.transform.location, str('%15.0f km/h' % (3.6 * math.sqrt(vector.x**2 + vector.y**2 + vector.z**2))), False, orange, 60)
        draw_transform(debug, current_w.transform, white, 60)

    # Update the current waypoint and sleep for some time
    current_w = next_w
    time.sleep(args.tick_time)
# ...

Copy snipet Close snipet

Snipet for carla.TrafficLight.set_state

  

# This recipe changes from red to green the traffic light that affects the vehicle. 
# This is done by detecting if the vehicle actor is at a traffic light.

# ...
world = client.get_world()
spectator = world.get_spectator()

vehicle_bp = random.choice(world.get_blueprint_library().filter('vehicle.bmw.*'))
transform = random.choice(world.get_map().get_spawn_points())
vehicle = world.try_spawn_actor(vehicle_bp, transform)

# Wait for world to get the vehicle actor
world.tick()

world_snapshot = world.wait_for_tick()
actor_snapshot = world_snapshot.find(vehicle.id)

# Set spectator at given transform (vehicle transform)
spectator.set_transform(actor_snapshot.get_transform())
# ...# ...
if vehicle_actor.is_at_traffic_light():
    traffic_light = vehicle_actor.get_traffic_light()
    if traffic_light.get_state() == carla.TrafficLightState.Red:
       # world.hud.notification("Traffic light changed! Good to go!")
        traffic_light.set_state(carla.TrafficLightState.Green)
# ...

Copy snipet Close snipet

Snipet for carla.DebugHelper.draw_box

  

# This recipe shows how to draw traffic light actor bounding boxes from a world snapshot.

# ....
debug = world.debug
world_snapshot = world.get_snapshot()

for actor_snapshot in world_snapshot:
    actual_actor = world.get_actor(actor_snapshot.id)
    if actual_actor.type_id == 'traffic.traffic_light':
        debug.draw_box(carla.BoundingBox(actor_snapshot.get_transform().location,carla.Vector3D(0.5,0.5,2)),actor_snapshot.get_transform().rotation, 0.05, carla.Color(255,0,0,0),0)
# ...

Copy snipet Close snipet

Snipet for carla.Client.__init__

  

# This recipe shows in every script provided in PythonAPI/Examples 
# and it is used to parse the client creation arguments when running the script. 

    argparser = argparse.ArgumentParser(
        description=__doc__)
    argparser.add_argument(
        '--host',
        metavar='H',
        default='127.0.0.1',
        help='IP of the host server (default: 127.0.0.1)')
    argparser.add_argument(
        '-p', '--port',
        metavar='P',
        default=2000,
        type=int,
        help='TCP port to listen to (default: 2000)')
    argparser.add_argument(
        '-s', '--speed',
        metavar='FACTOR',
        default=1.0,
        type=float,
        help='rate at which the weather changes (default: 1.0)')
    args = argparser.parse_args()

    speed_factor = args.speed
    update_freq = 0.1 / speed_factor

    client = carla.Client(args.host, args.port)

Copy snipet Close snipet

Snipet for carla.Sensor.listen

  

# This recipe applies a color conversion to the image taken by a camera sensor,
# so it is converted to a semantic segmentation image.

# ...
camera_bp = world.get_blueprint_library().filter('sensor.camera.semantic_segmentation')
# ...
cc = carla.ColorConverter.CityScapesPalette
camera.listen(lambda image: image.save_to_disk('output/%06d.png' % image.frame, cc))
# ...

Copy snipet Close snipet

Snipet for carla.World.spawn_actor

  

# This recipe attaches different camera / sensors to a vehicle with different attachments.

# ...
camera = world.spawn_actor(rgb_camera_bp, transform, attach_to=vehicle, attachment_type=Attachment.Rigid)
# Default attachment:  Attachment.Rigid
gnss_sensor = world.spawn_actor(sensor_gnss_bp, transform, attach_to=vehicle)
collision_sensor = world.spawn_actor(sensor_collision_bp, transform, attach_to=vehicle)
lane_invasion_sensor = world.spawn_actor(sensor_lane_invasion_bp, transform, attach_to=vehicle)
# ...

Copy snipet Close snipet

Snipet for carla.World.get_spectator

  

# This recipe spawns an actor and the spectator camera at the actor's location.

# ...
world = client.get_world()
spectator = world.get_spectator()

vehicle_bp = random.choice(world.get_blueprint_library().filter('vehicle.bmw.*'))
transform = random.choice(world.get_map().get_spawn_points())
vehicle = world.try_spawn_actor(vehicle_bp, transform)

# Wait for world to get the vehicle actor
world.tick()

world_snapshot = world.wait_for_tick()
actor_snapshot = world_snapshot.find(vehicle.id)

# Set spectator at given transform (vehicle transform)
spectator.set_transform(actor_snapshot.get_transform())
# ...

Copy snipet Close snipet

293 KiB Raw Blame History Unescape Escape

carla.Actor

Instance Variables

Methods

Getters

Setters

Dunder methods

carla.ActorAttribute

Instance Variables

Methods

Dunder methods

carla.ActorAttributeType

Instance Variables

carla.ActorBlueprint

Instance Variables

Methods

Getters

Setters

Dunder methods

carla.ActorList

Methods

Dunder methods

carla.ActorSnapshot

Instance Variables

Methods

Getters

carla.AttachmentType

Instance Variables

carla.BlueprintLibrary

Methods

Dunder methods

carla.BoundingBox

Instance Variables

Methods

Getters

Dunder methods

carla.CityObjectLabel

Instance Variables

carla.Client

Methods

Getters

Setters

carla.CollisionEvent

Instance Variables

carla.Color

Instance Variables

Methods

Dunder methods

carla.ColorConverter

Instance Variables

carla.DVSEvent

Instance Variables

Methods

Dunder methods

carla.DVSEventArray

Instance Variables

Methods

Dunder methods

carla.DebugHelper

Methods

carla.GearPhysicsControl

Instance Variables

Methods

Dunder methods

carla.GeoLocation

Instance Variables

Methods

Dunder methods

carla.GnssMeasurement

Instance Variables

Methods

Dunder methods

carla.IMUMeasurement

Instance Variables

Methods

Dunder methods

carla.Image

Instance Variables

Methods

Dunder methods

293 KiB

Raw Blame History