RVO2 Library

RVO2 is a C++98 implementation of the Optimal Reciprocal Collision Avoidance (ORCA) algorithm in two dimensions. It is designed for scenarios where multiple independent mobile agents (like robots) must avoid collisions with each other and static obstacles in a shared workspace without explicit communication.

Key features include:

• ORCA Algorithm: Provides collision-free motion by assigning half the responsibility of avoiding pairwise collisions to each agent.
• Efficiency: Reduces optimal action selection to solving low-dimensional linear programs, capable of handling thousands of agents in milliseconds.
• Parallelization: Uses OpenMP to exploit multiple processors for efficient simulation.
• Dynamic Control: The simulation is fully accessible and manipulable during runtime, allowing users to specify obstacles, agents, and preferred velocities step-by-step.

The RVO2 library provides a simple API for integration into third-party applications. To perform a simulation, a developer follows these conceptual steps:

1. Define the Environment: Specify static obstacles in the workspace.
2. Initialize Agents: Add agents to the simulation.
3. Set Intentions: Specify the preferred velocities for each agent (the velocity the agent wants to have if no collisions were present).
4. Step the Simulation: Perform the simulation step-by-step via library calls. The library computes collision-free velocities based on the current state and preferred velocities.

The public API of the RVO2 Library is defined exclusively by the symbols declared in the src/RVO.h header file. This header provides the interfaces for the following core components:

• RVOSimulator: The main simulation engine.
• Vector2: A 2D vector class.
• Line: A line segment class.

Internal implementation details, such as Agent, KdTree, and Obstacle, are not part of the public API and should not be relied upon for direct integration.

The library follows Semantic Versioning 2.0.0.

• API Stability: The public API is stable across patch and minor versions. Breaking changes are only introduced in new major versions.
• ABI Stability: ABI compatibility is maintained across patch versions within the same major.minor release series. New major or minor versions may introduce ABI-breaking changes.

Documentation is available in several formats:

• In-code Documentation: All features, parameters, and usage guides are documented using Doxygen markup within src/RVO.h and related headers.
• Example Code: Three annotated example programs demonstrate typical usage patterns (agents, obstacles, and step-wise simulation):
  • examples/Blocks.cc
  • examples/Circle.cc
  • examples/Roadmap.cc
• HTML Documentation: Can be generated from the source headers using CMake by setting the -DBUILD_DOCUMENTATION=ON flag.

The compose.yaml file defines a dev service used to set up a development environment for the RVO2 library using Docker. It builds an image from the local Dockerfile and mounts the current directory to /workspace inside the container with a cached volume flag to optimize performance.

services:
  dev:
    build:
      context: .
      dockerfile: Dockerfile
    volumes:
      - .:/workspace:cached

To advance the simulation in time, call doStep(). This updates the two-dimensional position and velocity of every agent in the simulation based on the current time step.

// In your simulation loop
while (running) {
    sim.doStep();
    // Update your visual representation using sim.getAgentPosition(id)
}

The queryVisibility method checks if two points are mutually visible given the current obstacles in the simulation.

Overloads:

1. queryVisibility(const Vector2 &point1, const Vector2 &point2): Returns true if the line segment between the points does not intersect any obstacles.
2. queryVisibility(const Vector2 &point1, const Vector2 &point2, float radius): Returns true if the line segment between the points maintains at least the specified radius distance from all obstacles.

Note: If processObstacles() has not been called yet, these methods return true by default.

RVO::Vector2 p1(0, 0);
RVO::Vector2 p2(10, 10);

if (sim.queryVisibility(p1, p2)) {
    // Path is clear
}

if (sim.queryVisibility(p1, p2, 0.5f)) {
    // Path is clear with a safety buffer of 0.5 units
}