p71924506
/
carla
mirror of https://github.com/carla-simulator/carla.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

added cpp client build docs (#7942)

This commit is contained in:
MattRoweEAIF 2024-07-11 14:40:52 +02:00 committed by GitHub
parent cf3cef936b
commit 4952c74729
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
4 changed files with 226 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

142
Docs/adv_cpp_client.md Normal file
View File

@ -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
```

6
Docs/build_linux_ue5.md
View File

@ -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

68
Docs/cpp_client_cmake_windows.md Normal file
View File

@ -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()
```

11
Docs/ref_cpp.md
View File

@ -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>