You are viewing an old version of this page. View the current version.

Compare with Current View Page History

« Previous Version 27 Next »


Short Summary Answer

Yes, OpenLR offers comprehensive documentation and open-source tools for implementation. Key resources include the official white paper, a Java-based reference implementation, and practical guides such as the HOWTO.md on GitHub. These resources cover encoding, decoding, and integration workflows to support both beginners and experienced developers.

Stakeholder Relevance / Rationale

  • Public Authorities: Access to well-documented, transparent technology supports procurement and compliance.

  • Content Providers: Facilitates integration into existing data pipelines through clearly defined formats and tools.

  • Service Providers: Accelerates development and integration with support from reference code and best-practice examples.

  • OEMs: Enables rapid prototyping and integration into in-vehicle systems using proven libraries and flow diagrams.

Detailed Explanation

Types / Versions / Formats

Use Cases

  • Custom Software Development: Developers can use or adapt the Java library to suit their platform (e.g., re-implement in C++, Python).

  • Integration with Map Engines: Compatible with tools like OpenStreetMap, GraphHopper, and OSRM.

  • Real-time Applications: Suited for transmitting dynamic location data efficiently between systems.

Technical Considerations

  • Encoder/Decoder Design: Requires both sides of the system to implement correct encoding and decoding logic.

  • Diagrams and Pseudo-Code: Included in the white paper and repository to support alternative language implementations.

  • No Hosted API: OpenLR is a library/specification—not a cloud service—so self-hosted integration is necessary.

Decision Guide

NeedResource/Tool
Understand the OpenLR conceptOpenLR White Paper
Understand the ISO TPEG2-OLR formats 

ISO 21219-22 – TPEG2-OLR Standard

Understand the ISO TPEG2-OLR encoding 

TISA Github 

Understand OpenLR encoding in DATEXII

DATEXII OpenLR™ (Point, linear and area location)

Implement OpenLR in JavaGitHub Repository
Implement OpenLR in python

OpenLR Python Documentation

Follow hands-on instructionsHOWTO.md Guide
Explore dynamic location usageINRIX Documentation
Re-implement in another language (e.g., C++)Use flow diagrams and algorithm logic from white paper and GitHub

Implementation Notes

  • There is no “plug-and-play” API; integration requires embedding the encoder and decoder into your own systems.

  • Ensure that test data is validated across both encoding and decoding ends to confirm map alignment.

  • Community forums and forks may offer additional language implementations or platform-specific tips.

References & Tools

Comments


Who

What

Decision

1TH / Aziya

Add OpenLR decoding Bits and Bytes explainer document OpenLR_Decoding_bits_and_bytes_v1.0.1.pdf

Approved
2Andras

TomTom version 2 OpenLR is still used → Aziya to check the status with David (see link)

Note to add that version 3 (current use) shall be used

Open
3


Processed comments meeting July 9th


Who

What

Decision

1THAdd TN-ITS CEN standard to be, DATEXII standard OpenLR 

Included:

 EN TS 16157, Part 14: TN-ITS

DATEXII OpenLR™ (Point, linear and area location)

2STMore python encoder/ decoders to check for links / inclusion in references
https://openlr-python.readthedocs.io/en/latest/		To be mentioned, TH included it in Q3 decision guide and references and tools section


Proposal 1 

Proposal text  (MS Copilot generated)

ChatGPTChatGPT Plus - OpenLR Guru

Yes, there is comprehensive implementation documentation available for OpenLR. Here are some key resources:

GitHub Repository

The OpenLR GitHub repository contains the reference implementation of OpenLR. It includes modules for encoding and decoding OpenLR locations, as well as tools for map access and data handling [1].

HOWTO.md

The HOWTO.md file in the GitHub repository provides detailed instructions on how to encode and decode OpenLR locations on digital maps [2].

INRIX Documentation

INRIX offers documentation on Dynamic Location Referencing, which includes information on OpenLR. This resource provides insights into the implementation tools available, such as the Java-based encoder/decoder and map access layer [3].

These resources should help you get started with implementing OpenLR in your projects.

References
[1] GitHub - tomtom-international/openlr: Reference implementation of ...
[2] openlr/HOWTO.md at master · tomtom-international/openlr - GitHub
[3] Dynamic Location Referencing - INRIX documentation

1. Official OpenLR Documentation (by TomTom)

📄 OpenLR White Paper (Core Specification)

  • The foundational document that explains:

    • The encoding/decoding process

    • Location reference types

    • Binary and XML formats

    • Algorithms for location matching

📍 Link: https://www.openlr.org/docs/OpenLR-whitepaper.pdf

✅ 2. OpenLR Reference Implementation (Java Library)

📦 Official GitHub Repository

  • TomTom’s open-source Java implementation of OpenLR

  • Includes:

    • Encoding/decoding tools

    • Sample map and test data

    • CLI tools

  • Great for understanding the logic and getting started with your own integration

📍 GitHub: https://github.com/TomTom/openlr

✅ 3. OpenLR Encoder/Decoder Flow Diagrams

  • The whitepaper and GitHub repo include helpful flow diagrams and pseudo-code for:

    • Finding candidate locations

    • Generating location references

    • Decoding them onto different maps

This helps if you're implementing OpenLR in a language other than Java (e.g., C++, Python, JavaScript).

✅ 4. Community/Examples

  • While OpenLR isn't widely discussed in public forums, you can find:

    • Example implementations or forks on GitHub (search "OpenLR").

    • Occasional integration notes in projects using OpenStreetMap or routing engines like GraphHopper or OSRM.

❗Note: No "Plug-and-Play" Web API

  • OpenLR is a specification and library, not a hosted API or web service.

  • You typically:

    • Integrate the encoder on your side (to generate references).

    • Transmit the encoded data (binary or base64).

    • Use the decoder on the recipient side to map-match to their own map data.

Bonus: Alternatives and Extensions

If your use case goes beyond what the core OpenLR offers, you might consider:

  • OpenLR+ (an extended version used internally by some companies)

  • Custom adaptations for area locations, GeoCoordinate encoding, etc.

 

Yes, there is detailed implementation documentation for OpenLR you can follow. Here's a summary of what's available and how you can use it:

📘 Official Documentation Sources

1. OpenLR Whitepaper (v1.5) – Core Specification

  • Explains logical structure, physical formats (binary & XML), encoding/decoding steps, data types.

  • Covers location types: line, point (including POI), and area (circle, rectangle, polygon, etc.).

  • Includes detailed attribute specifications: FRC, FOW, bearings, offsets.

📄 Your uploaded file: openlr-whitepaper_v1.5.pdf is the full spec
📄 openlr-whitepaper-errata_v1.5.pdf fixes known issues (e.g., ClosedLine bugs)

2. Reference Implementation on GitHub (TomTom)

Repo: github.com/tomtom-international/openlr

  • Modules:

    • encoder/: Java-based encoder converting map location to OpenLR

    • decoder/: Converts OpenLR back to map-specific location

    • map/: Interface you must implement to plug in your own map backend (OSM, HERE, etc.)

    • maploader-tt-sqlite/: Example for using TomTom maps

    • xml/, binary/: Serialization support

  • Build: Maven + Java 8

  • Docs: HOWTO.md explains integration and usage

🧪 Testing Tools

  • Includes unit tests for encoding/decoding various location types.

  • openlr-usage-sample module provides a minimal working example.

🧰 What You’ll Need to Implement

To integrate OpenLR:

  1. Implement the OpenLRMapReader interface to support your map (e.g., OSM, HERE).

  2. Use LocationEncoder and LocationDecoder APIs.

  3. Decide on binary vs XML encoding (or both).

  4. Handle map attribute translation (e.g., FRC/FOW normalization if using OSM).

✅ Additional Help

You can also explore:


Description of changes

<description of the changes>

Comments


Who

What

Decision

1


2


3




Input materials