rideOS
Published in

rideOS

Integrating Autonomous Vehicles with rideOS

At rideOS, we provide an a la carte selection of APIs for our partners so they can best achieve their individual goals. For instance, autonomous vehicle (AV) companies that need accurate ETAs and routes use our AV routing API to get custom routes tailored to the specific constraints of the vehicle. To integrate with a ride-hail network, they use our Dispatch APIs. You can sign up to explore and run our public APIs today. You can also try out our simulator and experiment with our ride-hail and routing services!

Because every rideOS API is a la carte, partners have the freedom to choose their level of integration. With more integration, autonomous vehicle fleets take advantage of rideOS’ rich ecosystem of data, services, and SDKs.

In the following examples, we illustrate how an AV partner can create an end-to-end ride-hailing network using their fleet of autonomous vehicles. We start with the lightest integration: visualizing and constraining HD maps, and end with a full integration of a dispatch service.

Map Ingestion and Updates

AVs typically run on high-definition maps (HD maps) that are built from 3D point clouds. These HD maps are used by AVs for a variety of purposes, such as localization, routing, and planning.

The problem is that there is no standard representation of a HD map, which means some products are tied to a specific map format. We avoid tying our products to certain map formats by first converting any HD map into our own partner-agnostic format, represented as a lane-level graph.

A partner-agnostic lane-level graph.

Once our partners’ HD maps have been ingested and turned into partner-agnostic lane-level graphs, our other services, such as routing and dispatch, can be run using the map data.

Creating a lane-level graph is an important foundation for routing an AV. However, in the real world, road conditions change all the time — certain lanes close for construction or events, or become blocked by debris or accidents. To enable our graph to reflect these dynamic changes, we created a Constraints API, which allows our partners to add and remove constraints in real-time.

For example, a partner could send an “avoid-area” constraint for Market Street in San Francisco (a notoriously busy and difficult-to-maneuver area) using our AddOrReplaceConstraints API, which would look like this:

{
"constraints": [
{
"id": "avoidMarketSt",
"tags": [
{
"key": "city",
"value": {
"string": "SF"
}
}
],
"avoidArea": {
"positions": [
{
"longitude": -122.3955,
"latitude": 37.7950
},
{
"longitude": -122.4372,
"latitude": 37.7628
},
{
"longitude": -122.4342,
"latitude": 37.7616
},
{
"longitude": -122.3943,
"latitude": 37.7943
},
{
"longitude": -122.3955,
"latitude": 37.7950
}
]
}
}
]
}

Upon receipt, the Constraints service would update their route to avoid the designated area.

In addition to our AddOrReplaceConstraints API, we also provide a front-end tool to allow our partners to add and remove avoid-areas from the web.

A simulated AV’s route before and after an avoid-area (shown in red) is added.

HD maps come in many flavors and formats, so we’ve built our service to ingest many HD map formats, such as Apollo, OpenDRIVE, RNDF, and even our partners’ proprietary formats, if needed. After this integration, developers can enjoy scalable visualizations of their HD map data, as well as the ability to specify constraints on their map.

AV Routing

Generally, an AV requires both routing and path planning in order to safely drive on the streets (check out our previous blog post on AV routing at rideOS). One way to describe the difference between the two is that routing focuses on where to drive (e.g., use the right lane of Main Street, then turn right onto the right lane of Market Street), and path planning focuses on how to drive (e.g., stop at red traffic lights).

Current AVs always need a destination to drive to. These include, for example, a passenger’s pickup or dropoff location. When our partners send us desired destinations for their AVs, we supply paths for the AVs to follow while obeying given constraints (e.g., the AV may only take right turns) and minimizing a cost function that takes into account distance, time, number of turns, and other factors.

For example, a partner could send us the following route request with our GetPath API:

{
"waypoints": [
{
"position": {
"latitude": 37.7904,
"longitude": -122.3922
},
"heading": 120
},
{
"position": {
"latitude": 37.7803,
"longitude": -122.5113
}
}
],
"geometryFormat": "LINESTRING",
"departureTime": "2018-10-09T16:22:13Z"
}

This route request contains waypoints — the first waypoint is typically the AV’s current position and the last is the AV’s destination. It’s also possible to choose more than two waypoints, for example, if the AV has to pick up two passengers and then drop them off at different locations.

Our GetPath API allows for the exclusion of edges, such as a particular lane on a road. And while the GetPath API is stateless, the route it returns accounts for real-time traffic and any defined avoid-areas. Route requests can be made by an AV itself or by a backend system from an AV partner. Here is an example result (with most position lat-lons removed) returned by our GetPath API:

{  
"departureTime":"2018-10-09T16:22:13Z",
"paths":[
{
"legs":[
{
"lineString":{
"positions":[
{
"latitude":37.790710000000004,
"longitude":-122.39178000000001
},
{
"latitude":37.7904745,
"longitude":-122.3914773
},
{
"latitude":37.7903502,
"longitude":-122.3913196
},
{
"latitude":37.7797734,
"longitude":-122.51071390000001
},
{
"latitude":37.779754000000004,
"longitude":-122.51078980000001
},
{
"latitude":37.7797295,
"longitude":-122.51086780000001
}
]
},
"travelTime":"1851.118s",
"violatedEdgeExclusions":[
],
"distance":14787.520941334375
}
],
"travelTime":"1851.118s",
"distance":14787.520941334375
}
]
}

Fleet Management and Dispatch

In order to support dispatch services for fleets (matching rider requests to the best available AV in a given fleet while taking into account the AV’s capabilities and constraints), we provide a number of different APIs:

  • A rider request API that allows for the specification of origin and destination locations, as well as the number of passengers to be picked up. This API can be called from a rider app (provided by our AV partner) or from our AV partner’s backend system.
  • Fleet Planner APIs that create an optimal global plan of multiple rider requests for an AV fleet. The Fleet Planner APIs allow our AV partners to perform tasks such as planning fixed AV routes for daily commuters — this API is covered in detail in another blog post.
  • APIs for adding and removing vehicles in a fleet and for real-time ride-sharing capabilities, that call the Fleet Planner APIs. Ride-sharing allows a single AV to fulfill multiple passenger requests concurrently, thus improving the efficiency of the AV fleet. Our ride-sharing APIs solve a multi-rider to multi-vehicle matching problem, and each AV receives its own plan (i.e., its portion of the global solution, for example, to pick up a passenger, pick up a second passenger, drop off the second passenger, then drop off the first passenger). Given the plan from our ride-sharing solution, the AV can then call our GetPath API with multiple waypoints to receive a route to execute the solution.
A simulated AV’s route with 3 ride-sharing passengers and an avoid-area.

We also support multiple fleets within a partner’s AV ecosystem, which means our partners can have, for example, one fleet of multiple AVs performing rider-related services while another fleet of AVs collects map data.

All of our APIs can be used on their own or with each other — have a look at the video of our simulator demonstrating ride-sharing with an avoid-area!

Next Steps

If you are interested in trying out our APIs and simulator for yourself, sign up here. You can run them in real-time and let us know what you think!

Or, if you’d like to help us build out our a la carte services, come join us at rideos.ai/careers!

--

--

--

Accelerating the safe, global roll-out of human-driven and autonomously-controlled transportation

Recommended from Medium

Managed IT Services in Walton-on-Trent #Managed #IT #Services #Walton-on-Trent https://t.co/yD0mwAZ7

Creating Ammo Count Feature in Unity

Simple service discovery with SRV records and HAProxy

Newly-Introduced JUnit 5 Annotations and Classes. @DisplayName annotation

Ultimate Guide To Numpy For Machine Learning.

How to Disable Adobe’s Creative Cloud Background Processes.

Splitting stories like a journalist

To Check If Key Exists In Dictionary :Python

Get the Medium app

A button that says 'Download on the App Store', and if clicked it will lead you to the iOS App store
A button that says 'Get it on, Google Play', and if clicked it will lead you to the Google Play store
Allison Liemhetcharat

Allison Liemhetcharat

Proud mom, roboticist, software engineer.

More from Medium

How to Create Installer for JxBrowser Application

Linux kernel & driver exploration

Goroutine, They are simpler than you think!(Part 1)