carla-simulator · MattRoweEAIF · Jul 11, 2024 · Jul 17, 2024 · Jul 19, 2024 · Jul 25, 2024
@@ -1,4 +1,5 @@
 ## Latest Changes
+ * Fixed a bug that caused navigation information not to be loaded when switching maps
  * Prevent from segfault on failing SignalReference identification when loading OpenDrive files
  * Added vehicle doors to the recorder
  * Added functions to get actor' components transform
@@ -18,6 +19,7 @@
  * PythonAPI `Sensor.is_listening` was defined twice (property and method), cleaned and clarified it as a method.
  * Added V2X sensors for cooperative awareness message and custom user-defined messages to support vehicle-to-vehicle communication
  * Added named tuples for BasicAgent.py's detection result to allow for type-hints and better semantics.
+ * Added type-hint support for the PythonAPI
 
 
 ## CARLA 0.9.15

@@ -0,0 +1,142 @@
+# C++ client example
+
+To build the C++ client example you will need `make` installed. Before building a C++ client, you will need to build CARLA, follow the relevant [build instructions](build_carla.md) for your platform. 
+
+Navigate to the `Examples/CppClient` folder in the CARLA repository and open a terminal. You will find a Makefile in this directory. To build and run it in Linux execute `make run` at the command prompt. In Windows, create a file named `CMakeLists.txt` in the same directory and add the contents in [this file](cpp_client_cmake_windows.md), then run `cmake`.
+
+This C++ example will connect to the server, spawn a vehicle and apply a command to the vehicle before destroying it and terminating. 
+
+### Include the relevant header files
+
+For this example, we will be using several different CARLA classes, so we need to include the relevant header files from the CARLA library and include any standard libraries we will use:
+
+```cpp
+#include <iostream>
+#include <random>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <thread>
+#include <tuple>
+
+#include <carla/client/ActorBlueprint.h>
+#include <carla/client/BlueprintLibrary.h>
+#include <carla/client/Client.h>
+#include <carla/client/Map.h>
+#include <carla/client/Sensor.h>
+#include <carla/client/TimeoutException.h>
+#include <carla/client/World.h>
+#include <carla/geom/Transform.h>
+#include <carla/image/ImageIO.h>
+#include <carla/image/ImageView.h>
+#include <carla/sensor/data/Image.h>
+
+```
+
+### Connecting the C++ client to the server
+
+Include `carla/client/Client.h` and then connect the client:
+
+```cpp
+...
+#include <carla/client/Client.h>
+...
+int main(int argc, const char *argv[]) {
+
+    std::string host;
+    uint16_t port;
+    std::tie(host, port) = ParseArguments(argc, argv);
+    ...
+    // Connect the client to the server
+    auto client = cc::Client(host, port);
+    client.SetTimeout(40s);
+```
+
+### Load a map
+
+Now let's load a randomly chosen map:
+
+```cpp
+// Initialize random number generator
+std::mt19937_64 rng((std::random_device())());
+...
+auto town_name = RandomChoice(client.GetAvailableMaps(), rng);
+std::cout << "Loading world: " << town_name << std::endl;
+auto world = client.LoadWorld(town_name);
+```
+
+### Spawn a randomly chosen vehicle
+
+Next we will fetch the blueprint library, filter for vehicles and choose a random vehicle blueprint:
+
+```cpp
+auto blueprint_library = world.GetBlueprintLibrary();
+auto vehicles = blueprint_library->Filter("vehicle");
+auto blueprint = RandomChoice(*vehicles, rng);
+```
+
+Now we need to find a location to spawn the vehicle from a spawn point in the map. We will get a pointer reference to the map object and then choose a random spawn point (ensure you have initialized the random number generator):
+
+```cpp
+auto map = world.GetMap();
+auto transform = RandomChoice(map->GetRecommendedSpawnPoints(), rng);
+```
+
+Now we have the blueprint and spawn location, we can now spawn the vehicle using the `world.SpawnActor(...)` method:
+
+```cpp
+auto actor = world.SpawnActor(blueprint, transform);
+std::cout << "Spawned " << actor->GetDisplayId() << '\n';
+// Retrieve a pointer to the vehicle object
+auto vehicle = boost::static_pointer_cast<cc::Vehicle>(actor);
+```
+
+### Apply a control
+
+Let's now apply some control to the vehicle to move it using the `ApplyControl(...)` method:
+
+```cpp
+cc::Vehicle::Control control;
+control.throttle = 1.0f;
+vehicle->ApplyControl(control);
+```
+
+Now we will relocate the spectator so that we can see our newly spawned vehicle in the map:
+
+```cpp
+auto spectator = world.GetSpectator();
+// Adjust the transform to look 
+transform.location += 32.0f * transform.GetForwardVector();
+transform.location.z += 2.0f;
+transform.rotation.yaw += 180.0f;
+transform.rotation.pitch = -15.0f;
+// Now set the spectator transform
+spectator->SetTransform(transform);
+```
+
+We'll also sleep the process for 10 seconds to observe the simulation shortly, before the client closes:
+
+
+```cpp
+std::this_thread::sleep_for(10s);
+
+```
+
+If you wish to keep the client open while other commands are executed, create a game loop. Now you have loaded a map and spawned a vehicle. To further explore the C++ API [build the Doxygen documentation](ref_cpp.md#c-documentation) and open it in a browser. 
+
+To build the C++ client in another location outside of the CARLA repository, edit the first 5 lines of the Makefile to reference the correct locations for the `/build` directory and the CARLA build location:
+
+```make
+CARLADIR=$(CURDIR)/../..
+BUILDDIR=$(CURDIR)/build
+BINDIR=$(CURDIR)/bin
+INSTALLDIR=$(CURDIR)/libcarla-install
+TOOLCHAIN=$(CURDIR)/ToolChain.cmake
+```
+
+
+
+
+
+
+
@@ -15,6 +15,8 @@
 
 The __Digital Twin Tool__ enables procedural generation of unique 3D environments based on road networks derived from the [OpenStreetMap](https://www.openstreetmap.org) (OSM) service. Through the Digital Twin Tool interface in CARLA's Unreal Engine editor a user can select a region of map from OSM and download the road network as the basis for a new CARLA map. The tool then fills the spaces between the roads with procedurally generated 3D buildings that adjust to the layout of the road, creating a realistic 3D road environment with high variability.
 
+<iframe width="100%" height="400px" src="https://www.youtube.com/embed/gTutXdS2UkQ?si=hssM3YRCAjSIzdXM" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>
+
 ## Building the OSM renderer
 
 If you are using Linux, you have the option of using the OSM renderer in the CARLA interface to navigate a large OSM map region that you have downloaded. You first need to build the OSM renderer before proceeding to build CARLA. Run `make osmrenderer` inside the CARLA root directory. You may need to upgrade your version of CMake to v3.2 or above in order for this to work. This will create two folders in your build directory called `libosmcout-source` and `libosmcout-build`. Before proceeding to build CARLA, you need to then edit the `Build.sh` file in the directory `$CARLA_ROOT/Build/libosmcout-source/maps` like so, to ensure the executable is found:

@@ -129,7 +129,7 @@ pip3 install --user -Iv setuptools==47.3.1 &&
 pip install --user distro &&
 pip3 install --user distro &&
 pip install --user wheel &&
-pip3 install --user wheel auditwheel
+pip3 install --user wheel auditwheel==4.0.0
 ```
 
 ---

@@ -88,4 +88,8 @@ If you want to install the Python API corresponding to the package you have buil
 
 ```sh
 pip3 install PythonAPI/carla/dist/carla-*.whl
-```
+```
+
+## Additional build targets
+
+The procedure outlined above will download all necessary components to build CARLA, you may not want to 
@@ -1,7 +1,7 @@
 !!! warning
         This is a work in progress!! This version of CARLA is not considered a stable release. Over the following months many significant changes may be made to this branch which could break any modifications you make. We advise you to treat this branch as experimental.
 
-# Building CARLA in Windowswith Unreal Engine 5.3
+# Building CARLA in Windows with Unreal Engine 5.3
 
 ## Set up the environment
 

@@ -0,0 +1,68 @@
+```make
+cmake_minimum_required(VERSION 3.5.1)
+project(example)
+
+link_directories(
+    ${RPCLIB_LIB_PATH})
+
+file(GLOB example_sources "*.cpp" "*.h")
+
+file(GLOB example_client_sources "")
+
+set(carla_config client)
+list(APPEND build_targets example_${carla_config}_debug)
+
+# Create targets for debug and release in the same build type.
+foreach(target ${build_targets})
+
+  add_executable(${target} ${example_sources})
+
+  target_compile_definitions(${target} PUBLIC
+      -DLIBCARLA_ENABLE_PROFILER)
+
+  target_include_directories(${target} SYSTEM PRIVATE
+      "../../LibCarla/source"
+      "../../Build/boost-1.80.0-install/include"
+      "../../Build/rpclib-install/include/"
+      "../../Build/recast-22dfcb-install/include/"
+      "../../Build/zlib-install/include/"
+      "../../Build/libpng-1.2.37-install/include/"
+      "../../LibCarla/source/third-party/")
+
+  target_link_directories(${target} SYSTEM PRIVATE
+      "../../Build/boost-1.80.0-install/lib"
+      "../../Build/rpclib-install/lib/"
+      "../../Build/recast-22dfcb-install/lib/"
+      "../../Build/zlib-install/lib/"
+      "../../Build/libcarla-visualstudio/LibCarla/cmake/client/Release/"
+      "../../Build/libpng-1.2.37-install/lib/")
+
+  target_include_directories(${target} PRIVATE
+      "${libcarla_source_path}/test")
+
+  if (WIN32)
+      target_link_libraries(${target} "rpc.lib")
+      target_link_libraries(${target} "carla_client.lib")
+      target_link_libraries(${target} "DebugUtils.lib")
+      target_link_libraries(${target} "Detour.lib")
+      target_link_libraries(${target} "DetourCrowd.lib")
+      target_link_libraries(${target} "DetourTileCache.lib")
+      target_link_libraries(${target} "Recast.lib")
+      target_link_libraries(${target} "Shlwapi.lib")
+  else()
+      target_link_libraries(${target} "-lrpc")
+  endif()
+
+  install(TARGETS ${target} DESTINATION test OPTIONAL)
+endforeach(target)
+
+if (LIBCARLA_BUILD_DEBUG)
+  # Specific options for debug.
+  set_target_properties(example_${carla_config}_debug PROPERTIES COMPILE_FLAGS "${CMAKE_CXX_FLAGS_DEBUG}")
+  target_link_libraries(example_${carla_config}_debug "carla_${carla_config}${carla_target_postfix}_debug")
+  target_compile_definitions(example_${carla_config}_debug PUBLIC -DBOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
+  if (CMAKE_BUILD_TYPE STREQUAL "Client")
+      target_link_libraries(example_${carla_config}_debug "${BOOST_LIB_PATH}/libboost_filesystem.a")
+  endif()
+endif()
+```
@@ -1999,7 +1999,7 @@ Iterate over the [carla.RadarDetection](#carla.RadarDetection) retrieved as data
 
 ## carla.Rotation<a name="carla.Rotation"></a>
 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.  <br>
-<br>The constructor method follows a specific order of declaration: `(pitch, yaw, roll)`, which corresponds to `(Y-rotation,Z-rotation,X-rotation)`.  <br> <br>![UE4_Rotation](https://d26ilriwvtzlb.cloudfront.net/8/83/BRMC_9.jpg) *Unreal Engine's coordinates system*.  
+<br>The constructor method follows a specific order of declaration: `(pitch, yaw, roll)`, which corresponds to `(Y-rotation,Z-rotation,X-rotation)`.  <br> <br>![UE4_Rotation](/img/unreal_lhcs.png) *Unreal Engine's coordinates system*.  
 
 ### Instance Variables
 - <a name="carla.Rotation.pitch"></a>**<font color="#f8805a">pitch</font>** (_float<small> - degrees</small>_)  

@@ -1,4 +1,15 @@
 # C++ Reference 
+
+## C++ client
+
+The C++ client can be built with `make` on Linux and `cmake` in Windows. An C++ client example is provided in the repository in `CARLA_ROOT/Examples/CppClient/main.cpp`. This example shows how to connect the C++ client to the CARLA server and use the API for some simple tasks. 
+
+To build the example C++ client, open a terminal in the `CARLA_ROOT/Examples/CppClient` directory in the repository. Run `make` in this folder and then execute `./bin/cpp_client` to run the example. The example will choose a random map from those available then load it. It will then spawn a vehicle and apply a control to the vehicle. 
+
+Please see the [C++ client example](adv_cpp_client.md) for more details on this example script.
+
+## C++ documentation
+
 We use Doxygen to generate the documentation of our C++ code:
 
 [Libcarla/Source](http://carla.org/Doxygen/html/dir_b9166249188ce33115fd7d5eed1849f2.html)<br>

@@ -186,10 +186,11 @@ Provides measures that accelerometer, gyroscope and compass would retrieve for t
 | `timestamp`        | double | Simulation time of the measurement in seconds since the beginning of the episode.        |
 | `transform`        | [carla.Transform](<../python_api#carlatransform>)  | Location and rotation in world coordinates of the sensor at the time of the measurement. |
 | `accelerometer`      | [carla.Vector3D](<../python_api#carlavector3d>)    | Measures linear acceleration in `m/s^2`.     |
-| `gyroscope`        | [carla.Vector3D](<../python_api#carlavector3d>)    | Measures angular velocity in `rad/sec`.      |
-| `compass`          | float | Orientation in radians. North is `(0.0, -1.0, 0.0)` in UE.       |
-
+| `gyroscope`        | [carla.Vector3D](<../python_api#carlavector3d>)    | Measures angular velocity in `rad/s`.      |
+| `compass`          | float | Orientation in radians. North is 0 radians.     |
 
+!!! note
+     For the compass, North is 0 radians. East is *pi*/2 radians, South is *pi* radians, West is 3*pi*/2 radians. North is in the direction of decreasing Y in CARLA's global coordinate system. East is in the direction of increasing X. The compass value converted to degrees is equal to 90 - yaw.
 
 ---
 ## Lane invasion detector
@@ -735,7 +736,7 @@ The following tags are currently available (Note, tags changed from version 0.9.
 | `14`           | Car            | `(0, 0, 142)`    | Cars, vans        |
 | `15`           | Truck          | `(0, 0, 70)`    | Trucks        |
 | `16`           | Bus            | `(0, 60, 100)`  | Busses        |
-| `17`           | Train          | `(0, 60, 100)`  | Trains        |
+| `17`           | Train          | `(0, 80, 100)`  | Trains        |
 | `18`           | Motorcycle     | `(0, 0, 230)`    | Motorcycle, Motorbike        |
 | `19`           | Bicycle        | `(119, 11, 32)`   | Bicylces      |
 | `20`           | Static         | `(110, 190, 160)`            | Elements in the scene and props that are immovable. <br> E.g. fire hydrants, fixed benches, fountains, bus stops, etc.    |
@@ -939,21 +940,19 @@ While the visibility is simulated within CARLA, the scenario can be configured b
 *   __Output:__ [carla.CAMData](python_api.md#carla.CAMData), triggered according to the ETSI CAM standard, unless configured otherwise
 
 Triggering conditions according to ETSI standard:
-- Heading angle change > $4$°
-- Position difference > $4$ m
-- Speed change > $5$ m/s
+- Heading angle change > 4°
+- Position difference > 4 m
+- Speed change > 5 m/s
 - Time elapsed > CAM Generation time (configurable)
-- Low Frequency Container Time Elapsed $> 500$ ms
+- Low Frequency Container Time Elapsed > 500 ms
 
 For the CAM V2X sensor, additional blueprint attributes apply:
 
 | Blueprint attribute     | Type   | Default  | Description                        |
 |-------------------------|--------|-------------------------|------------------------------------|
-| <td colspan=4> Message generation | 
-| gen\_cam\_min           | float  | $0.1$         |  Minimum elapsed time between two successive CAMs in seconds (s)        |
-| gen\_cam\_max           | float  | $1.0$       |   Maximum elapsed time between two successive CAMs in seconds (s)          |
+| gen\_cam\_min           | float  | 0.1         |  Minimum elapsed time between two successive CAMs in seconds (s)        |
+| gen\_cam\_max           | float  | 1.0       |   Maximum elapsed time between two successive CAMs in seconds (s)          |
 | fixed\_rate             | bool   | false [true]     |  Generate a CAM in every CARLA tick (only for debug purposes, will result in slowdown)    |
-| <td colspan=4> Data generation | 
 | `noise_vel_stddev_x` | float  | 0\.0   | Standard deviation parameter in the noise model for velocity (X axis). |
 | `noise_accel_stddev_x`          | float   | 0\.0    | Standard deviation parameter in the noise model for acceleration (X axis).  |
 | `noise_accel_stddev_y`          | float   | 0\.0    | Standard deviation parameter in the noise model for acceleration (Y axis).  |
@@ -992,14 +991,14 @@ Example:
 
 | Blueprint attribute     | Type   | Default | Description                        |
 |-------------------------|--------|-------------------------|------------------------------------|
-| transmit\_power         | float  | $21.5$       | Sender transmission power in dBm                         |
-| receiver\_sensitivity   | float  | $-99$        | Receiver sensitivity in dBm                                |
-| frequency\_ghz          | float  | $5.9$ | Transmission frequency in GHz. 5.9 GHz is standard for several physical channels.                 |
-| noise\_seed             | int    | $0$   | Random parameter for initialization of noise                           |
-| filter\_distance        | float  | $500$      | Maximum transmission distance in meter, path loss calculations above are skipped for simulation speed      |
-| <td colspan=4> __Path loss model parameters__ |
-| combined\_antenna\_gain | float  | $10.0$   | Combined gain of sender and receiver antennas in dBi, parameter for radiation efficiency and directivity |
-| d\_ref                  | float  | $ 1.0 $    | reference distance for Log-distance path loss model in meter           |
+| transmit\_power         | float  | 21.5       | Sender transmission power in dBm                         |
+| receiver\_sensitivity   | float  | -99        | Receiver sensitivity in dBm                                |
+| frequency\_ghz          | float  | 5.9 | Transmission frequency in GHz. 5.9 GHz is standard for several physical channels.                 |
+| noise\_seed             | int    | 0   | Random parameter for initialization of noise                           |
+| filter\_distance        | float  | 500      | Maximum transmission distance in meter, path loss calculations above are skipped for simulation speed      |
+| __Path loss model parameters__ | | | |
+| combined\_antenna\_gain | float  | 10.0   | Combined gain of sender and receiver antennas in dBi, parameter for radiation efficiency and directivity |
+| d\_ref                  | float  | 1.0     | reference distance for Log-distance path loss model in meter           |
 | path\_loss\_exponent    | float  | 2.7                     |    Loss parameter for non-line of sight due to building obstruction    |
 | scenario                | string | urban   | Options: [urban, rural, highway], defines the fading noise parameters |
 | path\_loss\_model       | string | geometric     |   general path loss model to be used. Options: [geometric, winner]  |

@@ -88,6 +88,12 @@ namespace detail {
     const auto id = GetCurrentEpisode().GetId();
     _client.LoadEpisode(std::move(map_name), reset_settings, map_layers);
 
+    // delete the pointer to _episode so that the Navigation information
+    // will be loaded for the correct map
+    assert(_episode.use_count() == 1);
+    _episode.reset();
+    GetReadyCurrentEpisode();
+
     // We are waiting 50ms for the server to reload the episode.
     // If in this time we have not detected a change of episode, we try again
     // 'number_of_attempts' times.