### Iterate Through Junctions and Connections

Source: https://context7.com/pageldev/libopendrive/llms.txt

This C++ snippet demonstrates how to load an OpenDRIVE map, retrieve all junctions, and iterate through their connections, lane links, priorities, and controllers. It also shows how to get a specific junction by its ID.

```cpp
#include "OpenDriveMap.h"
#include <iostream>

int main() {
    odr::OpenDriveMap odr_map("road_network.xodr");

    // Get all junctions
    std::vector<odr::Junction> junctions = odr_map.get_junctions();
    std::cout << "Total junctions: " << junctions.size() << std::endl;

    for (const odr::Junction& junction : junctions) {
        std::cout << "\nJunction ID: " << junction.id
                  << ", Name: " << junction.name << std::endl;

        // Iterate through connections
        for (const auto& [conn_id, connection] : junction.id_to_connection) {
            std::cout << "  Connection: " << connection.id << std::endl;
            std::cout << "    Incoming road: " << connection.incoming_road << std::endl;
            std::cout << "    Connecting road: " << connection.connecting_road << std::endl;

            // Contact point indicates where the connecting road attaches
            std::string contact = (connection.contact_point == odr::JunctionConnection::ContactPoint::Start)
                                  ? "start" : "end";
            std::cout << "    Contact point: " << contact << std::endl;

            // Lane links define lane-to-lane connections
            for (const odr::JunctionLaneLink& link : connection.lane_links) {
                std::cout << "    Lane link: " << link.from << " -> " << link.to << std::endl;
            }
        }

        // Junction priorities (right-of-way)
        for (const odr::JunctionPriority& priority : junction.priorities) {
            std::cout << "  Priority: " << priority.high << " over " << priority.low << std::endl;
        }

        // Junction controllers (traffic lights, etc.)
        for (const auto& [ctrl_id, controller] : junction.id_to_controller) {
            std::cout << "  Controller: " << controller.id
                      << ", Type: " << controller.type
                      << ", Sequence: " << controller.sequence << std::endl;
        }
    }

    // Get specific junction by ID
    odr::Junction junction = odr_map.get_junction("123");

    return 0;
}
```

--------------------------------

### Build libOpenDRIVE from Source

Source: https://context7.com/pageldev/libopendrive/llms.txt

Commands to clone, configure, and build the library using CMake, including options for shared libraries and testing.

```bash
# Clone the repository
git clone https://github.com/pageldev/libOpenDRIVE.git
cd libOpenDRIVE

# Create build directory
mkdir build && cd build

# Configure and build static library (default)
cmake ..
make

# Or build shared library
cmake -DBUILD_SHARED_LIBS=ON ..
make

# Build with tests enabled
cmake -DOPENDRIVE_BUILD_TESTS=ON ..
make
ctest  # Run tests

# Install the library
sudo make install
```

--------------------------------

### Build libOpenDRIVE from Source

Source: https://github.com/pageldev/libopendrive/blob/main/README.md

Commands to compile the library using CMake. Use the shared library flag if dynamic linking is required.

```bash
mkdir build
cd build
cmake ..
make
```

```bash
cmake -DBUILD_SHARED_LIBS=ON ..
```

--------------------------------

### Performing Pathfinding with RoutingGraph in C++

Source: https://context7.com/pageldev/libopendrive/llms.txt

Shows how to compute the shortest path between two lanes and query lane successors and predecessors using the RoutingGraph.

```cpp
#include "OpenDriveMap.h"
#include <iostream>

int main() {
    odr::OpenDriveMap odr_map("road_network.xodr");

    // Get routing graph from map
    odr::RoutingGraph routing_graph = odr_map.get_routing_graph();

    // Define start and end points using LaneKey (road_id, lanesection_s0, lane_id)
    odr::LaneKey from("17", 0.0, 1);   // Road 17, first lane section, lane 1
    odr::LaneKey to("41", 0.0, -1);    // Road 41, first lane section, lane -1

    // Compute shortest path
    std::vector<odr::LaneKey> path = routing_graph.shortest_path(from, to);

    std::cout << "Shortest path (" << path.size() << " segments):" << std::endl;
    for (const odr::LaneKey& lane_key : path) {
        std::cout << "  Road: " << lane_key.road_id
                  << ", LaneSection s0: " << lane_key.lanesection_s0
                  << ", Lane ID: " << lane_key.lane_id << std::endl;
    }

    // Get lane successors (where can we go from this lane?)
    odr::LaneKey current("43", 0.0, 1);
    std::vector<odr::LaneKey> successors = routing_graph.get_lane_successors(current);
    std::cout << "\nSuccessors of " << current.to_string() << ":" << std::endl;
    for (const odr::LaneKey& succ : successors) {
        std::cout << "  -> " << succ.to_string() << std::endl;
    }

    // Get lane predecessors (where can we come from?)
    std::vector<odr::LaneKey> predecessors = routing_graph.get_lane_predecessors(current);
    std::cout << "\nPredecessors of " << current.to_string() << ":" << std::endl;
    for (const odr::LaneKey& pred : predecessors) {
        std::cout << "  <- " << pred.to_string() << std::endl;
    }

    // Access raw graph edges
    std::cout << "\nTotal routing edges: " << routing_graph.edges.size() << std::endl;

    return 0;
}
```

--------------------------------

### Accessing LaneSection and Lane Information in C++

Source: https://context7.com/pageldev/libopendrive/llms.txt

Demonstrates how to retrieve lane sections, iterate through lanes, check connectivity, and query lane properties at specific coordinates.

```cpp
#include "OpenDriveMap.h"
#include <iostream>

int main() {
    odr::OpenDriveMap odr_map("road_network.xodr");
    odr::Road road = odr_map.get_road("17");

    // Get all lane sections in a road
    std::vector<odr::LaneSection> lane_sections = road.get_lanesections();
    std::cout << "Number of lane sections: " << lane_sections.size() << std::endl;

    // Get lane section at specific s coordinate
    double s = 5.0;
    odr::LaneSection ls = road.get_lanesection(s);
    std::cout << "Lane section at s=" << s << " starts at s0=" << ls.s0 << std::endl;

    // Get lane section boundaries
    double ls_start = ls.s0;
    double ls_end = road.get_lanesection_end(ls);
    double ls_length = road.get_lanesection_length(ls);
    std::cout << "Lane section: s0=" << ls_start << " to " << ls_end
              << " (length: " << ls_length << "m)" << std::endl;

    // Iterate through all lanes in a section
    for (const odr::Lane& lane : ls.get_lanes()) {
        std::cout << "  Lane ID: " << lane.id
                  << ", Type: " << lane.type
                  << ", Level: " << (lane.level ? "true" : "false") << std::endl;

        // Check lane connectivity
        if (lane.predecessor.has_value()) {
            std::cout << "    Predecessor lane: " << lane.predecessor.value() << std::endl;
        }
        if (lane.successor.has_value()) {
            std::cout << "    Successor lane: " << lane.successor.value() << std::endl;
        }
    }

    // Get specific lane by ID
    odr::Lane lane = ls.get_lane(-1);  // Right-most driving lane
    std::cout << "Lane -1 type: " << lane.type << std::endl;

    // Get lane at specific (s, t) coordinates
    double t = 3.5;
    int lane_id = ls.get_lane_id(s, t);
    odr::Lane lane_at_pos = ls.get_lane(s, t);
    std::cout << "Lane at (s=" << s << ", t=" << t << "): ID=" << lane_id
              << ", Type=" << lane_at_pos.type << std::endl;

    // Access lane key for routing
    odr::LaneKey key = lane.key;
    std::cout << "Lane key: " << key.to_string() << std::endl;

    // Get road marks for a lane
    std::vector<odr::RoadMark> roadmarks = lane.get_roadmarks(ls_start, ls_end);
    for (const odr::RoadMark& rm : roadmarks) {
        std::cout << "  RoadMark: type=" << rm.type
                  << ", s=[" << rm.s_start << ", " << rm.s_end << "]"
                  << ", width=" << rm.width << std::endl;
    }

    return 0;
}
```

--------------------------------

### Parse and Analyze OpenDRIVE Maps in C++

Source: https://github.com/pageldev/libopendrive/blob/main/README.md

Demonstrates loading an OpenDRIVE file, iterating through roads, calculating 3D coordinates, accessing lane attributes, computing routing paths, and generating a 3D mesh.

```c++
// load map
odr::OpenDriveMap odr_map("tests/test.xodr");

// iterate roads
for (odr::Road road : odr_map.get_roads())
    std::cout << "road: " << road.id << " length: " << road.length << std::endl;

// get xyz point for road coordinates
odr::Road odr_road = odr_map.get_road("17");
odr::Vec3D pt_xyz = odr_road.get_xyz(2.1 /*s*/, 1.0 /*t*/, 0.0 /*h*/);

// access road network attributes
std::string lane_type = odr_road.get_lanesection(0.0).get_lane(-1).type;

// use routing graph
odr::RoutingGraph routing_graph = odr_map.get_routing_graph();
odr::LaneKey from("17" /*road id*/, 0.0 /*lane section s0*/, 1 /*lane id*/);
odr::LaneKey to("41", 0.0, -1);
std::vector<odr::LaneKey> path = routing_graph.shortest_path(from, to);

// get road network mesh
odr::RoadNetworkMesh road_network_mesh = odr_map.get_road_network_mesh(0.1 /*eps*/);
std::cout << road_network_mesh.get_mesh().get_obj() << std::endl;
```

--------------------------------

### Accessing RefLine Data and Geometry

Source: https://context7.com/pageldev/libopendrive/llms.txt

Demonstrates loading an OpenDRIVE map, accessing a specific road's reference line, and utilizing its core methods for geometric queries and approximations. Requires an 'road_network.xodr' file and a road with ID '17'.

```cpp
#include "OpenDriveMap.h"
#include <iostream>

int main() {
    odr::OpenDriveMap odr_map("road_network.xodr");
    odr::Road road = odr_map.get_road("17");

    // Access reference line
    const odr::RefLine& ref_line = road.ref_line;
    std::cout << "Reference line length: " << ref_line.length << "m" << std::endl;

    // Get XYZ position along reference line
    double s = 5.0;
    odr::Vec3D xyz = ref_line.get_xyz(s);
    std::cout << "Position at s=" << s << ": (" 
              << xyz[0] << ", " << xyz[1] << ", " << xyz[2] << ")" << std::endl;

    // Get derivative (tangent direction) at position
    odr::Vec3D tangent = ref_line.derivative(s);
    std::cout << "Tangent at s=" << s << ": (" 
              << tangent[0] << ", " << tangent[1] << ", " << tangent[2] << ")" << std::endl;

    // Generate 3D polyline representation
    double eps = 0.1;
    odr::Line3D line = ref_line.get_line(0.0, ref_line.length, eps);
    std::cout << "Reference line approximation: " << line.size() << " points" << std::endl;

    // Match XY coordinates to s parameter (projection onto reference line)
    double x = xyz[0], y = xyz[1];
    double s_matched = ref_line.match(x, y);
    std::cout << "Matched s for (" << x << ", " << y << "): " << s_matched << std::endl;

    // Get linear approximation sample points
    std::set<double> sample_s = ref_line.approximate_linear(eps, 0.0, ref_line.length);
    std::cout << "Sample points for eps=" << eps << ": " << sample_s.size() << std::endl;

    // Access geometry segments
    std::set<const odr::RoadGeometry*> geometries = ref_line.get_geometries();
    std::cout << "Number of geometry segments: " << geometries.size() << std::endl;

    // Get specific geometry at s position
    const odr::RoadGeometry* geom = ref_line.get_geometry(s);
    if (geom) {
        double geom_s0 = ref_line.get_geometry_s0(s);
        std::cout << "Geometry at s=" << s << " starts at s0=" << geom_s0 << std::endl;
    }

    return 0;
}
```

--------------------------------

### Generate and Export Road Network Mesh

Source: https://context7.com/pageldev/libopendrive/llms.txt

Demonstrates loading an OpenDRIVE map, generating a 3D mesh with a specified epsilon, accessing individual components, and exporting the result to an OBJ file.

```cpp
#include "OpenDriveMap.h"
#include <iostream>
#include <fstream>

int main() {
    odr::OpenDriveMap odr_map("road_network.xodr");

    // Generate road network mesh with specified resolution
    double eps = 0.1;  // Approximation epsilon (smaller = more detailed)
    odr::RoadNetworkMesh road_network_mesh = odr_map.get_road_network_mesh(eps);

    // Access individual mesh components
    odr::LanesMesh& lanes = road_network_mesh.lanes_mesh;
    odr::RoadmarksMesh& roadmarks = road_network_mesh.roadmarks_mesh;
    odr::RoadObjectsMesh& objects = road_network_mesh.road_objects_mesh;
    odr::RoadSignalsMesh& signals = road_network_mesh.road_signals_mesh;

    std::cout << "Lanes mesh vertices: " << lanes.vertices.size() << std::endl;
    std::cout << "Roadmarks mesh vertices: " << roadmarks.vertices.size() << std::endl;
    std::cout << "Road objects mesh vertices: " << objects.vertices.size() << std::endl;
    std::cout << "Road signals mesh vertices: " << signals.vertices.size() << std::endl;

    // Get combined mesh
    odr::Mesh3D combined_mesh = road_network_mesh.get_mesh();
    std::cout << "Combined mesh vertices: " << combined_mesh.vertices.size() << std::endl;
    std::cout << "Combined mesh triangles: " << combined_mesh.indices.size() / 3 << std::endl;

    // Export to OBJ format
    std::string obj_content = combined_mesh.get_obj();
    std::ofstream obj_file("road_network.obj");
    obj_file << obj_content;
    obj_file.close();
    std::cout << "Exported to road_network.obj" << std::endl;

    // Query mesh for specific road/lane information
    if (!lanes.vertices.empty()) {
        size_t vert_idx = 0;
        std::string road_id = lanes.get_road_id(vert_idx);
        double lanesec_s0 = lanes.get_lanesec_s0(vert_idx);
        int lane_id = lanes.get_lane_id(vert_idx);
        std::cout << "Vertex 0 belongs to: Road=" << road_id
                  << ", LaneSection s0=" << lanesec_s0
                  << ", Lane=" << lane_id << std::endl;

        // Get vertex index intervals
        auto [road_start, road_end] = lanes.get_idx_interval_road(vert_idx);
        auto [lane_start, lane_end] = lanes.get_idx_interval_lane(vert_idx);
        std::cout << "Road vertex range: [" << road_start << ", " << road_end << ")" << std::endl;
        std::cout << "Lane vertex range: [" << lane_start << ", " << lane_end << ")" << std::endl;
    }

    // Get lane outline indices for boundary extraction
    std::vector<size_t> outline_indices = lanes.get_lane_outline_indices();
    std::cout << "Lane outline vertices: " << outline_indices.size() << std::endl;

    return 0;
}
```

--------------------------------

### Load and Parse OpenDRIVE Map

Source: https://context7.com/pageldev/libopendrive/llms.txt

Load an OpenDRIVE map with default or custom parsing options. Access basic map information like projection and offset.

```cpp
#include "OpenDriveMap.h"
#include <iostream>

int main() {
    // Load OpenDRIVE map with default options
    odr::OpenDriveMap odr_map("road_network.xodr");

    // Load with custom options
    odr::OpenDriveMap odr_map_custom(
        "road_network.xodr",
        true,   // center_map - center the map around origin
        true,   // with_road_objects - parse road objects
        true,   // with_lateral_profile - parse lateral profile (crossfall, superelevation)
        true,   // with_lane_height - parse lane height offsets
        false,  // abs_z_for_for_local_road_obj_outline - use absolute z for local outlines
        true,   // fix_spiral_edge_cases - handle spiral geometry edge cases
        true    // with_road_signals - parse traffic signals
    );

    // Access projection and offset information
    std::cout << "Proj4: " << odr_map.proj4 << std::endl;
    std::cout << "X offset: " << odr_map.x_offs << std::endl;
    std::cout << "Y offset: " << odr_map.y_offs << std::endl;

    // Get all roads
    std::vector<odr::Road> roads = odr_map.get_roads();
    std::cout << "Total roads: " << roads.size() << std::endl;

    // Get specific road by ID
    odr::Road road = odr_map.get_road("17");
    std::cout << "Road ID: " << road.id << ", Length: " << road.length << "m" << std::endl;

    // Get all junctions
    std::vector<odr::Junction> junctions = odr_map.get_junctions();
    std::cout << "Total junctions: " << junctions.size() << std::endl;

    return 0;
}
```

--------------------------------

### Generate Road Element Meshes in C++

Source: https://context7.com/pageldev/libopendrive/llms.txt

Use the `Road` class to generate meshes for lanes, lane borders, roadmarks, objects, and signals. Specify mesh resolution with `eps`. Lane meshes can be generated for a specific s-range.

```cpp
#include "OpenDriveMap.h"
#include <iostream>

int main() {
    odr::OpenDriveMap odr_map("road_network.xodr");
    odr::Road road = odr_map.get_road("17");

    double eps = 0.1;  // Mesh resolution

    // Generate mesh for a specific lane
    odr::LaneSection ls = road.get_lanesection(0.0);
    odr::Lane lane = ls.get_lane(-1);

    // Full lane mesh
    std::vector<uint32_t> outline_indices;
    odr::Mesh3D lane_mesh = road.get_lane_mesh(lane, eps, &outline_indices);
    std::cout << "Lane mesh: " << lane_mesh.vertices.size() << " vertices, "
              << lane_mesh.indices.size() / 3 << " triangles" << std::endl;
    std::cout << "Outline indices: " << outline_indices.size() << std::endl;

    // Lane mesh for specific s range
    double s_start = 0.0;
    double s_end = 10.0;
    odr::Mesh3D partial_mesh = road.get_lane_mesh(lane, s_start, s_end, eps);

    // Generate lane border line (3D polyline)
    odr::Line3D outer_border = road.get_lane_border_line(lane, eps, true);  // outer = true
    odr::Line3D inner_border = road.get_lane_border_line(lane, eps, false); // outer = false
    std::cout << "Outer border points: " << outer_border.size() << std::endl;
    std::cout << "Inner border points: " << inner_border.size() << std::endl;

    // Generate road mark meshes
    std::vector<odr::RoadMark> roadmarks = lane.get_roadmarks(ls.s0, road.get_lanesection_end(ls));
    for (const odr::RoadMark& rm : roadmarks) {
        odr::Mesh3D rm_mesh = road.get_roadmark_mesh(lane, rm, eps);
        std::cout << "Roadmark mesh (" << rm.type << "): "
                  << rm_mesh.vertices.size() << " vertices" << std::endl;
    }

    // Generate road object meshes
    for (const odr::RoadObject& obj : road.get_road_objects()) {
        odr::Mesh3D obj_mesh = road.get_road_object_mesh(obj, eps);
        std::cout << "Road object '" << obj.name << "' (type=" << obj.type << "): "
                  << obj_mesh.vertices.size() << " vertices" << std::endl;
    }

    // Generate road signal meshes
    for (const odr::RoadSignal& signal : road.get_road_signals()) {
        odr::Mesh3D signal_mesh = road.get_road_signal_mesh(signal);
        std::cout << "Signal '" << signal.name << "' (type=" << signal.type << "): "
                  << signal_mesh.vertices.size() << " vertices" << std::endl;
    }

    // Static mesh generators for basic shapes
    odr::Mesh3D cylinder = odr::RoadObject::get_cylinder(eps, 0.5, 2.0);  // radius, height
    odr::Mesh3D box = odr::RoadObject::get_box(1.0, 2.0, 0.5);            // width, length, height

    return 0;
}
```

--------------------------------

### Access RoadObject and RoadSignal Data in C++

Source: https://context7.com/pageldev/libopendrive/llms.txt

Iterate through road networks to extract metadata, dimensions, and positioning for road objects and traffic signals.

```cpp
#include "OpenDriveMap.h"
#include <iostream>

int main() {
    odr::OpenDriveMap odr_map("road_network.xodr");

    for (const odr::Road& road : odr_map.get_roads()) {
        // Access road objects
        std::vector<odr::RoadObject> objects = road.get_road_objects();
        for (const odr::RoadObject& obj : objects) {
            std::cout << "Road Object: " << obj.id << std::endl;
            std::cout << "  Name: " << obj.name << std::endl;
            std::cout << "  Type: " << obj.type << ", Subtype: " << obj.subtype << std::endl;
            std::cout << "  Position: s=" << obj.s0 << ", t=" << obj.t0 << ", z=" << obj.z0 << std::endl;
            std::cout << "  Dimensions: " << obj.width << " x " << obj.length << " x " << obj.height << std::endl;
            std::cout << "  Orientation: hdg=" << obj.hdg << ", pitch=" << obj.pitch << ", roll=" << obj.roll << std::endl;
            std::cout << "  Dynamic: " << (obj.is_dynamic ? "yes" : "no") << std::endl;

            // Check for repeated objects
            if (!obj.repeats.empty()) {
                std::cout << "  Repeats: " << obj.repeats.size() << std::endl;
                for (const odr::RoadObjectRepeat& rep : obj.repeats) {
                    std::cout << "    s0=" << rep.s0 << ", length=" << rep.length
                              << ", distance=" << rep.distance << std::endl;
                }
            }

            // Check for outline definitions
            if (!obj.outlines.empty()) {
                std::cout << "  Outlines: " << obj.outlines.size() << std::endl;
                for (const odr::RoadObjectOutline& outline : obj.outlines) {
                    std::cout << "    Points: " << outline.outline.size()
                              << ", Closed: " << (outline.closed ? "yes" : "no") << std::endl;
                }
            }

            // Lane validity (which lanes the object applies to)
            for (const odr::LaneValidityRecord& validity : obj.lane_validities) {
                std::cout << "  Valid for lanes: " << validity.from_lane
                          << " to " << validity.to_lane << std::endl;
            }
        }

        // Access road signals (traffic signs, lights)
        std::vector<odr::RoadSignal> signals = road.get_road_signals();
        for (const odr::RoadSignal& sig : signals) {
            std::cout << "Road Signal: " << sig.id << std::endl;
            std::cout << "  Name: " << sig.name << std::endl;
            std::cout << "  Type: " << sig.type << ", Subtype: " << sig.subtype << std::endl;
            std::cout << "  Country: " << sig.country << std::endl;
            std::cout << "  Position: s=" << sig.s0 << ", t=" << sig.t0 << std::endl;
            std::cout << "  Dimensions: " << sig.width << " x " << sig.height << std::endl;
            std::cout << "  Value: " << sig.value << " " << sig.unit << std::endl;
            std::cout << "  Text: " << sig.text << std::endl;
            std::cout << "  Dynamic: " << (sig.is_dynamic ? "yes" : "no") << std::endl;
            std::cout << "  Orientation: " << sig.orientation << std::endl;
        }
    }

    return 0;
}
```

--------------------------------

### Access Road Geometry and Attributes

Source: https://context7.com/pageldev/libopendrive/llms.txt

Iterate through roads, access their properties, and perform coordinate transformations from road (s, t, h) to XYZ. Also access speed limits and road types.

```cpp
#include "OpenDriveMap.h"
#include <iostream>

int main() {
    odr::OpenDriveMap odr_map("road_network.xodr");

    // Iterate through all roads
    for (const odr::Road& road : odr_map.get_roads()) {
        std::cout << "Road: " << road.id
                  << ", Name: " << road.name
                  << ", Length: " << road.length << "m"
                  << ", Junction: " << road.junction << std::endl;

        // Check road connectivity
        if (road.predecessor.type != odr::RoadLink::Type::None) {
            std::cout << "  Predecessor: " << road.predecessor.id << std::endl;
        }
        if (road.successor.type != odr::RoadLink::Type::None) {
            std::cout << "  Successor: " << road.successor.id << std::endl;
        }
    }

    // Get specific road
    odr::Road road = odr_map.get_road("17");

    // Convert road coordinates (s, t, h) to XYZ
    // s = distance along reference line, t = lateral offset, h = height offset
    double s = 2.1;  // 2.1 meters along the road
    double t = 1.0;  // 1.0 meter lateral offset (positive = left)
    double h = 0.0;  // 0.0 meter height offset

    odr::Vec3D e_s, e_t, e_h;  // Optional: get tangent vectors
    odr::Vec3D pt_xyz = road.get_xyz(s, t, h, &e_s, &e_t, &e_h);
    std::cout << "XYZ position: (" << pt_xyz[0] << ", " << pt_xyz[1] << ", " << pt_xyz[2] << ")" << std::endl;

    // Get surface point with normal vector
    odr::Vec3D normal;
    odr::Vec3D surface_pt = road.get_surface_pt(s, t, &normal);
    std::cout << "Surface normal: (" << normal[0] << ", " << normal[1] << ", " << normal[2] << ")" << std::endl;

    // Access speed limits along the road
    for (const auto& [s_pos, speed] : road.s_to_speed) {
        std::cout << "Speed limit at s=" << s_pos << ": " << speed.max << " " << speed.unit << std::endl;
    }

    // Access road type information
    for (const auto& [s_pos, type] : road.s_to_type) {
        std::cout << "Road type at s=" << s_pos << ": " << type << std::endl;
    }

    return 0;
}
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.