Segment

Segments are paths which can be traveled by people or objects.

Geometry Type	LineString
Theme	transportation
Type	segment

Segment geometry represents the center-line of a path that a person or object may travel. Segment properties describe both the physical attributes (e.g. road surface and width) and non-physical attributes (e.g. access restriction rules) of that path.

Two segments are physically connected if a common connector is referenced from the connector property of both segments. Where this occurs, both segment geometries must contain the common connector's coordinates. A physical connection between segments indicates that it may be possible to travel from one segment to the next at the connected location provided the segment properties do not indicate a restriction, such as a turn restriction, which would prevent the transition. Conversely, two segments are not physically connected -— even if their geometries intersect —- if they do not share a common connector.

Subtypes

A segment may have one of three possible subtypes.

Road

subtype	road

A road segment represents a section of any kind of road, street or path, including a dedicated path for walking or cycling, but excluding a railway.

Railway

subtype	rail

The schema for rail segments is under development.

Waterway

subtype	water

The schema for water segments is under development.

Schema

Browsable

Loading ....

YAML

---
"$schema": https://json-schema.org/draft/2020-12/schema
title: segment
description: >-
  Segments are paths which can be traveled by people or things. Segments
  are compatible with GeoJSON LineString features.
type: object
properties:
  id:
    "$ref": ../defs.yaml#/$defs/propertyDefinitions/id
  geometry:
    description: >-
      Segment's geometry which MUST be a LineSting as defined by GeoJSON
      schema.
    unevaluatedProperties: false
    allOf:
      - "$ref": https://geojson.org/schema/LineString.json
  properties:
    unevaluatedProperties: false
    required: [subtype]
    allOf:
      - title: "Segment Properties"
        properties:
          class: { "$ref": "#/$defs/propertyDefinitions/roadClass" }
          subclass: { "$ref": "#/$defs/propertyDefinitions/subclass" }
          subclass_rules: { "$ref": "#/$defs/propertyContainers/subclassRulesContainer" }
          access_restrictions: { "$ref": "#/$defs/propertyContainers/accessContainer" }
          level: { "$ref": "../defs.yaml#/$defs/propertyDefinitions/level" }
          level_rules: { "$ref": "#/$defs/propertyContainers/levelRulesContainer" }
      - title: "Conditional Properties"
        if: { properties: { subtype: { enum: [road] } } }
        then:
          required: [class]
          properties:
            destinations: { "$ref": "#/$defs/propertyDefinitions/destinations" }
            lanes: { "$ref": "#/$defs/propertyContainers/lanesContainer" }
            prohibited_transitions: { "$ref": "#/$defs/propertyContainers/prohibitedTransitionsContainer" }
            road_surface: { "$ref": "#/$defs/propertyContainers/surfaceContainer"}
            road_flags: { "$ref": "#/$defs/propertyContainers/flagsContainer" }
            speed_limits: { "$ref": "#/$defs/propertyContainers/speedLimitsContainer" }
            width_rules: { "$ref": "#/$defs/propertyContainers/widthRulesContainer" }
      - "$ref": ../defs.yaml#/$defs/propertyContainers/overtureFeaturePropertiesContainer
      - "$ref": ../defs.yaml#/$defs/propertyContainers/namesContainer
    properties:
      subtype:
        description: Broad category of transportation segment.
        type: string
        enum: [road, rail, water]
        "$comment": >-
          Should not be confused with a transport mode. A segment
          kind has an (implied) set of default transport modes.
      connector_ids:
        description: >-
          ** Deprecated** `connector_ids` is deprecated in favor of `connectors` and
          is planned to be removed for the October release.

          List of connector IDs identifying the connectors this segment is physically
          connected to. Each connector is a possible routing decision point, meaning
          it defines a place along the segment in which there is possibility to
          transition to other segments which share the same connector.
        type: array
        items:
          type: string
          "$comment": >-
            Each entry in this array is the GERS ID of a transportation connector feature.
        uniqueItems: true
        minItems: 2
        default: []
      connectors:
        description: >-
          List of connectors which this segment is physically connected to and their
          relative location. Each connector is a possible routing decision point, meaning
          it defines a place along the segment in which there is possibility to
          transition to other segments which share the same connector.
        type: array
        items:
          type: object
          "$comment": >-
            Contains the GERS ID and relative position between 0 and 1 of a connector feature along the segment.
          unevaluatedProperties: false
          required: [connector_id, at]
          properties:
            connector_id: { "$ref": "../defs.yaml#/$defs/propertyDefinitions/id" }
            at: { "$ref": "../defs.yaml#/$defs/propertyDefinitions/linearlyReferencedPosition" }
        uniqueItems: true
        minItems: 2
        default: []
      routes: { "$ref": "#/$defs/propertyDefinitions/routes" }
"$defs":
  propertyDefinitions:
    destinationLabelType:
      description: >-
        The type of object of the destination label.
      type: string
      enum:
      - street
      - country
      - route_ref
      - toward_route_ref
      - unknown
    destinations:
      description: >-
        Describes objects that can be reached by following a transportation segment in the
        same way those objects are described on signposts or ground writing that a traveller
        following the segment would observe in the real world. This allows navigation systems
        to refer to signs and observable writing that a traveller actually sees.
      type: array
      items:
        type: object
        unevaluatedProperties: false
        required: [from_connector_id, to_connector_id, to_segment_id, final_heading]
        anyOf:
          - required: [labels]
          - required: [symbols]
        properties:
          labels:
            description: >-
              Labeled destinations that can be reached by following the segment.
            type: array
            items:
              type: object
              unevaluatedProperties: false
              required: [value, type]
              properties:
                value:
                  description: >-
                    Names the object that is reached
                  type: string
                  pattern: ^(\S.*)?\S$
                type: { "$ref": "#/$defs/propertyDefinitions/destinationLabelType" }
            minItems: 1
            uniqueItems: true
          symbols:
            description: >-
              A collection of symbols or icons present on the sign next to current
              destination label.
            type: array
            items: { "$ref": "#/$defs/propertyDefinitions/destinationSignSymbol" }
            uniqueItems: true
            minLength: 1
          from_connector_id:
            description: >-
              Identifies the point of physical connection on this segment before which
              the destination sign or marking is visible.
            type: string
          to_segment_id:
            description: >-
              Identifies the segment to transition to reach the destination(s) labeled
              on the sign or marking.
            type: string
          to_connector_id:
            description: >-
              Identifies the point of physical connection on the segment identified by
              'to_segment_id' to transition to for reaching the destination(s).
            type: string
          when:
            allOf:
              - "$ref": "#/$defs/propertyContainers/headingScopeContainer"
            minProperties: 1
            unevaluatedProperties: false
          final_heading:
            description: >-
              Direction of travel on the segment identified by 'to_segment_id' that leads
              to the destination.
            "$ref": "#/$defs/propertyDefinitions/heading"
    roadClass:
      description:
        Captures the kind of road and its position in the road network
        hierarchy.
      type: string
      enum:
        - motorway
        - primary
        - secondary
        - tertiary
        - residential
        - living_street   # Similar to residential but has implied legal restriction for motor vehicles (which can vary country by country)
        - trunk
        - unclassified    # Known roads, paved, but subordinate to all of: motorway, trunk, primary, secondary, tertiary
        - service         # Provides vehicle access to a feature (such as a building), typically not part of the public street network
        - pedestrian
        - footway         # Minor segments mainly used by pedestrians
        - steps
        - path
        - track
        - cycleway
        - bridleway       # Similar to track but has implied access only for horses
        - unknown
    lane:
      description: Properties for a single lane of traffic.
      type: object
      unevaluatedProperties: false
      required: [direction]
      properties:
        direction: { "$ref": "#/$defs/propertyDefinitions/laneDirection" }
        restrictions:
          description: Restrictions on how the lane may be used
          "$comment": >-
            Lane restrictions may be defined in the same way as for whole roads with the exception
            of turns; there are no turn restrictions for lanes.
          type: object
          unevaluatedProperties: false
          properties:
            speed_limits:
              "$ref": "#/$defs/propertyContainers/speedLimitsContainer"
            access:
              "$ref": "#/$defs/propertyContainers/accessContainer"
            min_occupancy:
              description: >-
                Minimal occupancy restrictions relate to HOV (high occupancy vehicles) travel modes.
                If a lane is restricted for use only by HOVs, then the default minimum vehicle
                occupancy qualifying as HOV is 2+ passengers (including the driver).  This
                restriction can be provided to override the default definition of HOV.
              type: integer
              minimum: 1
    laneDirection:
      type: string
      enum:
        - forward       # Traffic flows in the segment direction.
        - backward      # Traffic flows against the segment direction.
        - both_ways     # Traffic flows simultaneously in both directions as, e.g., on a sidewalk.
        - alternating   # Traffic flows alternately forward and backward following a predictable rhythm.
        - reversible    # Traffic flows forward, but may be arbitrarily reversed by traffic authorities at any time.
    heading:
      description: >-
        Enumerates possible travel headings along segment geometry.
      type: string
      enum: [ forward, backward ]
    travelMode:
      description: >-
        Enumerates possible travel modes. Some modes represent groups
        of modes.
      type: string
      enum: [ vehicle, motor_vehicle, car, truck, motorcycle, foot, bicycle, bus, hgv, hov, emergency ]
      "$comment": >-
        motor_vehicle includes car, truck and motorcycle
    destinationSignSymbol:
      description: >-
        Indicates what special symbol/icon is present on a signpost, visible as road marking or similar.
      type: string
      enum:
      - motorway
      - airport
      - hospital
      - center             # center of a locality, city center or downtown, from centre in raw OSM value
      - industrial
      - parking
      - bus
      - train_station
      - rest_area
      - ferry
      - motorroad
      - fuel
      - viewpoint
      - fuel_diesel
      - food               # 'food', 'restaurant' in OSM
      - lodging
      - info
      - camp_site
      - interchange
      - restrooms          # 'toilets' in OSM
    roadFlag:
      description: >-
        Simple flags that can be on or off for a road segment. Specifies physical characteristics and can overlap.
      type: string
      enum:
        - is_bridge
        - is_link # Note: `is_link` is deprecated and will be removed in a future release in favor of the link subclass
        - is_tunnel
        - is_under_construction
        - is_abandoned
        - is_covered
    roadSurface:
      description: Physical surface of the road
      type: string
      enum:
        - unknown
        - paved
        - unpaved
        - gravel
        - dirt
        - paving_stones
        - metal
    routes:
      description: Routes this segment belongs to
      type: array
      items:
        type: object
        unevaluatedProperties: false
        allOf:
          - { "$ref": "../defs.yaml#/$defs/propertyContainers/geometricRangeScopeContainer" }
        properties:
          name:
            description: Full name of the route
            type: string
            minLength: 1
            pattern: ^(\S.*)?\S$    # Leading and trailing whitespace are not allowed.
          network:
            description: Name of the highway system this route belongs to
            type: string
            minLength: 1
            pattern: ^(\S.*)?\S$    # Leading and trailing whitespace are not allowed.
          ref:
            description: Code or number used to reference the route
            type: string
            minLength: 1
            pattern: ^(\S.*)?\S$    # Leading and trailing whitespace are not allowed.
          symbol:
            description: URL or description of route signage
            type: string
            minLength: 1
            pattern: ^(\S.*)?\S$    # Leading and trailing whitespace are not allowed.
          wikidata: { "$ref": "../defs.yaml#/$defs/propertyDefinitions/wikidata" }
    subclass:
      description: >-
        Refines expected usage of the segment, must not overlap.
      type: string
      enum:
        - link             # Connecting stretch (sliproad or ramp) between two road types
        - sidewalk         # Footway that lies along a road
        - crosswalk        # Footway that intersects other roads
        - parking_aisle    # Service road intended for parking
        - driveway         # Service road intended for deliveries
        - alley            # Service road intended for rear entrances, fire exits
        - cycle_crossing   # Cycleway that intersects with other roads
    speed:
      description: >-
        A speed value, i.e. a certain number of distance units
        travelled per unit time.
      type: object
      properties:
        value:
          description: Speed value
          type: integer
          minimum: 1
          maximum: 350
        unit:
          description: Speed unit
          type: string
          enum:
            - km/h
            - mph
      required:
        - value
        - unit
      unevaluatedProperties: false
    purposeOfUse:
      description: >-
        Reason why a person or entity travelling on the transportation
        network is using a particular location.
      type: string
      enum:
        - as_customer
        - at_destination
        - to_deliver
        - to_farm
        - for_forestry
    recognizedStatus:
      description: >-
        Status of the person or entity travelling as recognized by
        authorities controlling the particular location
      type: string
      enum:
        - as_permitted
        - as_private
        - as_disabled
        - as_employee
        - as_student
    integerRelation:
      description: >-
        Completes an integer relational expression of the form
        <lhs> <operator> <integer_value>. An example of such an
        expression is:
          `{ axle_count: { is_more_than: 2 } }`.
      type: object
      unevaluatedProperties: false
      oneOf:
        - required: [is_more_than]
          properties: { is_more_than: { type: integer } }
        - required: [is_at_least]
          properties: { is_at_least: { type: integer } }
        - required: [is_equal_to]
          properties: { is_equal_to: { type: integer } }
        - required: [is_at_most]
          properties: { is_at_most: { type: integer } }
        - required: [is_less_than]
          properties: { is_less_than: { type: integer } }
    vehicleScopeDimension:
      description: Enumerates possible vehicle dimensions for use in restrictions
      type: string
      enum:
        - axle_count
        - height
        - length
        - weight
        - width
    vehicleScopeComparison:
      description: Enumerates possible comparison operators for use in scoping
      type: string
      enum:
        - greater_than
        - greater_than_equal
        - equal
        - less_than
        - less_than_equal
    vehicleScopeUnit:
      description: Parent enum of both length and width for use in vehicle scoping
      anyOf:
        - {"$ref": "#/$defs/propertyDefinitions/lengthUnit"}
        - {"$ref": "#/$defs/propertyDefinitions/weightUnit"}
    lengthUnit:
      description: Enumerates length units supported by the Overture schema.
      "$comment": Keep in sync with `combobulib/measure.py`.
      type: string
      enum:
        # Imperial units.
        - in            # Imperial: Inch.
        - ft            # Imperial: Foot.
        - yd            # Imperial: Yard.
        - mi            # Imperial: Mile.
        # SI units.
        - cm            # SI: centimeter.
        - m             # SI: meter.
        - km            # SI: kilometer.
    lengthValueWithUnit:
      description: Combines a length value with a length unit.
      type: object
      unevaluatedProperties: false
      required: [value, unit]
      properties:
        value:
          type: number
          minimum: 0
        unit: { "$ref": "#/$defs/propertyDefinitions/lengthUnit" }
    lengthRelation:
      description: >-
        Completes a length relational expression of the form
        <lhs> <operator> <length_value>. An example of such an
        expression is:
          `{ height: { is_less_than: { value: 3, unit: 'm' } } }`.
      type: object
      unevaluatedProperties: false
      oneOf:
        - required: [is_more_than]
          properties: { is_more_than: { allOf: [ { "$ref": "#/$defs/propertyDefinitions/lengthValueWithUnit" } ] } }
        - required: [is_at_least]
          properties: { is_at_least: { allOf: [ { "$ref": "#/$defs/propertyDefinitions/lengthValueWithUnit" } ] } }
        - required: [is_equal_to]
          properties: { is_equal_to: { allOf: [ { "$ref": "#/$defs/propertyDefinitions/lengthValueWithUnit" } ] } }
        - required: [is_at_most]
          properties: { is_at_most: { allOf: [ { "$ref": "#/$defs/propertyDefinitions/lengthValueWithUnit" } ] } }
        - required: [is_less_than]
          properties: { is_less_than: { allOf: [ { "$ref": "#/$defs/propertyDefinitions/lengthValueWithUnit" } ] } }
    weightUnit:
      description: Enumerates weight units supported by the Overture schema.
      "$comment": Keep in sync with `combobulib/measure.py`.
      type: string
      enum:
        # Imperial units.
        - oz            # Imperial: Ounce.
        - lb            # Imperial: Pound.
        - st            # Imperial: Short Ton.
        - lt            # Imperial: Long Ton.
        # SI units.
        - g             # SI: gram.
        - kg            # SI: kilogram.
        - t             # SI: tonne.
    weightValueWithUnit:
      description: Combines a weight value with a weight unit.
      type: object
      unevaluatedProperties: false
      required: [value, unit]
      properties:
        value:
          type: number
          minimum: 0
        unit: { "$ref": "#/$defs/propertyDefinitions/weightUnit" }
    weightRelation:
      description: >-
        Completes a weight relational expression of the form
        <lhs> <operator> <weight_value>. An example of such an
        expression is:
          `{ weight: { is_more_than: { value: 2, unit: 't' } } }`.
      type: object
      unevaluatedProperties: false
      oneOf:
        - required: [is_more_than]
          properties: { is_more_than: { allOf: [ { "$ref": "#/$defs/propertyDefinitions/weightValueWithUnit" } ] } }
        - required: [is_at_least]
          properties: { is_at_least: { allOf: [ { "$ref": "#/$defs/propertyDefinitions/weightValueWithUnit" } ] } }
        - required: [is_equal_to]
          properties: { is_equal_to: { allOf: [ { "$ref": "#/$defs/propertyDefinitions/weightValueWithUnit" } ] } }
        - required: [is_at_most]
          properties: { is_at_most: { allOf: [ { "$ref": "#/$defs/propertyDefinitions/weightValueWithUnit" } ] } }
        - required: [is_less_than]
          properties: { is_less_than: { allOf: [ { "$ref": "#/$defs/propertyDefinitions/weightValueWithUnit" } ] } }
    width:
      type: number
      exclusiveMinimum: 0
    sequenceEntry:
      description: >-
        A segment/connector pair in a prohibited transition sequence.
      type: object
      required: [connector_id, segment_id]
      properties:
        connector_id:
          description: >-
            Identifies the point of physical connection between the
            previous segment in the sequence and the segment in this
            sequence entry.
          type: string
        segment_id:
          description: >-
            Identifies the segment that the previous segment in the
            sequence is physically connected to via the sequence entry's
            connector.
          type: string
  propertyContainers:
    headingScopeContainer:
      description: Properties defining travel headings that match a rule.
      properties:
        heading:
          "$ref": "#/$defs/propertyDefinitions/heading"
    purposeOfUseScopeContainer:
      description: Properties defining usage purposes that match a rule.
      properties:
        using:
          type: array
          items:
            "$ref": "#/$defs/propertyDefinitions/purposeOfUse"
          uniqueItems: true
          minLength: 1
    temporalScopeContainer:
      "$comment": >-
        Temporal scoping properties defining the time spans when a
        recurring rule is active.
      properties:
        during:
          "$ref": ../defs.yaml#/$defs/propertyDefinitions/openingHours
    travelModeScopeContainer:
      description: Properties defining travel modes that match a rule.
      type: object
      properties:
        mode:
          description: Travel mode(s) to which the rule applies
          type: array
          items:
            "$ref": "#/$defs/propertyDefinitions/travelMode"
          uniqueItems: true
          minLength: 1
    recognizedStatusScopeContainer:
      description: Properties defining statuses that match a rule.
      properties:
        recognized:
          type: array
          items:
            "$ref": "#/$defs/propertyDefinitions/recognizedStatus"
          uniqueItems: true
          minLength: 1
    vehicleScopeContainer:
      description: >-
        Properties defining vehicle attributes for which a rule is
        active.
      type: object
      properties:
        vehicle:
          description: Vehicle attributes for which the rule applies
          type: array
          uniqueItems: true
          minLength: 1
          items:
            description: An individual vehicle scope rule
            type: object
            unevaluatedProperties: false
            required: [dimension, comparison, value]
            properties:
              dimension: { "$ref": "#/$defs/propertyDefinitions/vehicleScopeDimension" }
              comparison: { "$ref": "#/$defs/propertyDefinitions/vehicleScopeComparison" }
              value:
                type: number
                minimum: 0
              unit: { "$ref": "#/$defs/propertyDefinitions/vehicleScopeUnit" }
    speedLimitsContainer:
      description: Rules governing speed on this road segment or lane
      type: array
      items:
        description: An individual speed limit rule
        "$comment": >-
          TODO: Speed limits probably have directionality, so
          should factor out a headingScopeContainer for this
          purpose and use it to introduce an optional
          direction property in each rule.
        type: object
        anyOf:
          - required: [ min_speed ]
          - required: [ max_speed ]
        allOf:
          - "$ref": "../defs.yaml#/$defs/propertyContainers/geometricRangeScopeContainer"
        unevaluatedProperties: false
        properties:
          min_speed: { "$ref": "#/$defs/propertyDefinitions/speed" }
          max_speed: { "$ref": "#/$defs/propertyDefinitions/speed" }
          is_max_speed_variable:
            description: Indicates a variable speed corridor
            type: boolean
            default: false
          when:
            allOf:
              - "$ref": "#/$defs/propertyContainers/temporalScopeContainer"
              - "$ref": "#/$defs/propertyContainers/headingScopeContainer"
              - "$ref": "#/$defs/propertyContainers/purposeOfUseScopeContainer"
              - "$ref": "#/$defs/propertyContainers/recognizedStatusScopeContainer"
              - "$ref": "#/$defs/propertyContainers/travelModeScopeContainer"
              - "$ref": "#/$defs/propertyContainers/vehicleScopeContainer"
            minProperties: 1
            unevaluatedProperties: false
      minLength: 1
      uniqueItems: true
    accessContainer:
      description: Rules governing access to this road segment or lane
      type: array
      items:
        type: object
        unevaluatedProperties: false
        allOf:
          - { "$ref": "../defs.yaml#/$defs/propertyContainers/geometricRangeScopeContainer" }
        required: [access_type]
        properties:
          access_type:
            type: string
            enum: [allowed, denied, designated]
          when:
            allOf:
              - "$ref": "#/$defs/propertyContainers/temporalScopeContainer"
              - "$ref": "#/$defs/propertyContainers/headingScopeContainer"
              - "$ref": "#/$defs/propertyContainers/purposeOfUseScopeContainer"
              - "$ref": "#/$defs/propertyContainers/recognizedStatusScopeContainer"
              - "$ref": "#/$defs/propertyContainers/travelModeScopeContainer"
              - "$ref": "#/$defs/propertyContainers/vehicleScopeContainer"
            minProperties: 1
            unevaluatedProperties: false
        minLength: 1
        uniqueItems: true
    lanesContainer:
      description: >-
        List of lane block rules describing the layout of lanes on
        the road plus lane-related information. The standard rule
        evaluation algorithm is used to determine which lane block
        applies at a given place and time along the segment.

        Each lane block contains the list of lanes that make up the
        block. Lanes in the block are listed from left to right as
        they would be seen by a person standing on the road segment
        facing in the direction of the segment's orientation (toward
        the end).
      type: array
      items:
        type: object
        unevaluatedProperties: false
        allOf:
          - "$ref": "../defs.yaml#/$defs/propertyContainers/geometricRangeScopeContainer"
        properties:
          value:
            type: array
            items:  { "$ref": "#/$defs/propertyDefinitions/lane" }
            minItems: 1
          when:
            allOf:
              - "$ref": "#/$defs/propertyContainers/temporalScopeContainer"
            minProperties: 1
            unevaluatedProperties: false
      minItems: 1
      uniqueItems: true
    prohibitedTransitionsContainer:
      description: >-
        Rules preventing transitions from this segment to
        another segment.
      type: array
      items:
        type: object
        unevaluatedProperties: false
        allOf:
          - "$ref": "../defs.yaml#/$defs/propertyContainers/geometricRangeScopeContainer"
        required: [sequence, final_heading]
        properties:
          sequence:
            description: >-
              Ordered sequence of connector/segment pairs that it is
              prohibited to follow from this segment.
            type: array
            items:
              description: Pair of segment and connector IDs along the sequence
              "$ref": "#/$defs/propertyDefinitions/sequenceEntry"
            minItems: 1
            uniqueItems: true
          final_heading:
            description: >-
              Direction of travel that is prohibited on the destination
              segment of the sequence.
            "$ref": "#/$defs/propertyDefinitions/heading"
          when:
            allOf:
              - "$ref": "#/$defs/propertyContainers/headingScopeContainer"
              - "$ref": "#/$defs/propertyContainers/temporalScopeContainer"
              - "$ref": "#/$defs/propertyContainers/purposeOfUseScopeContainer"
              - "$ref": "#/$defs/propertyContainers/recognizedStatusScopeContainer"
              - "$ref": "#/$defs/propertyContainers/travelModeScopeContainer"
              - "$ref": "#/$defs/propertyContainers/vehicleScopeContainer"
            minProperties: 1
            unevaluatedProperties: false
    flagsContainer:
      description:
        Set of boolean attributes applicable to roads. May be
        specified either as a single flag array of flag values, or
        as an array of flag rules.
      type: array
      items:
        type: object
        allOf:
          - { "$ref": "../defs.yaml#/$defs/propertyContainers/geometricRangeScopeContainer" }
        unevaluatedProperties: false
        properties:
          values:
            type: array
            items: { "$ref": "#/$defs/propertyDefinitions/roadFlag" }
            uniqueItems: true
            minLength: 1
      uniqueItems: true
      minLength: 1
    levelRulesContainer:
      description:
        Defines the Z-order, i.e. stacking order, of the road
        segment.
      type: array
      items:
        description:
          A single level rule defining the Z-order, i.e. stacking
          order, applicable within a given scope on the road
          segment.
        type: object
        allOf:
          - { "$ref": "../defs.yaml#/$defs/propertyContainers/geometricRangeScopeContainer" }
        unevaluatedProperties: false
        required: [value]
        properties:
          value: { "$ref": "../defs.yaml#/$defs/propertyDefinitions/level" }
    subclassRulesContainer:
      description: Set of subclasses scoped along segment
      type: array
      items:
        type: object
        allOf:
          - { "$ref": "../defs.yaml#/$defs/propertyContainers/geometricRangeScopeContainer" }
        unevaluatedProperties: false
        properties:
          value: { "$ref": "#/$defs/propertyDefinitions/subclass" }
    surfaceContainer:
      description: Physical surface of the road. May either be
        specified as a single global value for the segment, or as
        an array of surface rules.
      type: array
      items:
        type: object
        allOf:
          - { "$ref": "../defs.yaml#/$defs/propertyContainers/geometricRangeScopeContainer" }
        unevaluatedProperties: false
        properties:
          value: { "$ref": "#/$defs/propertyDefinitions/roadSurface" }
      minItems: 1
      uniqueItems: true
      "$comment":
        We should likely restrict the available surface types to
        the subset of the common OSM surface=* tag values that are
        useful both for routing and for map tile rendering.
    widthRulesContainer:
      description: >-
        Edge-to-edge width of the road modeled by this segment, in
        meters.

        Examples: (1) If this segment models a carriageway without
        sidewalk, this value represents the edge-to-edge width of the
        carriageway, inclusive of any shoulder. (2) If this segment
        models a sidewalk by itself, this value represents the
        edge-to-edge width of the sidewalk. (3) If this segment models a
        combined sidewalk and carriageway, this value represents the
        edge-to-edge width inclusive of sidewalk.
      type: array
      items:
        type: object
        allOf:
          - { "$ref": "../defs.yaml#/$defs/propertyContainers/geometricRangeScopeContainer" }
        required: [value]
        properties:
          value: { "$ref": "#/$defs/propertyDefinitions/width" }
        unevaluatedProperties: false
      minItems: 1
      uniqueItems: true

Examples

Simple Road

{
  "id": "overture:transportation:example:simple-road",
  "type": "Feature",
  "geometry": {
    "type": "LineString",
    "coordinates": [
      [
        -123.13538016118466,
        49.28584368472093
      ],
      [
        -123.13430200328841,
        49.28656927229528
      ],
      [
        -123.13325122717998,
        49.28727252390803
      ]
    ]
  },
  "properties": {
    "theme": "transportation",
    "type": "segment",
    "version": 5,
    "subtype": "road",
    "class": "residential",
    "connector_ids": [
      "overture:transportation:example:via-turn-restriction-connector1",
      "overture:transportation:example:via-turn-restriction-connector2"
    ],
    "connectors": [
      {
        "connector_id": "overture:transportation:example:via-turn-restriction-connector1",
        "at": 0
      },
      {
        "connector_id": "overture:transportation:example:via-turn-restriction-connector2",
        "at": 1
      }
    ],
    "names": {
      "primary": "Nicola Street"
    },
    "lanes": [
      {
        "value": [
          {
            "direction": "backward"
          },
          {
            "direction": "forward"
          }
        ]
      }
    ],
    "road_surface": [
      {
        "value": "paved"
      }
    ]
  }
}

Lanes

{
  "id": "overture:transportation:example:simple-road2",
  "type": "Feature",
  "geometry": {
    "type": "LineString",
    "coordinates": [
      [
        -122.2421117,
        47.6382849
      ],
      [
        -122.2429835,
        47.6384385
      ],
      [
        -122.2442307,
        47.6386337
      ],
      [
        -122.2445016,
        47.6386753
      ]
    ]
  },
  "properties": {
    "theme": "transportation",
    "type": "segment",
    "subtype": "road",
    "version": 2,
    "class": "secondary",
    "lanes": [
      {
        "value": [
          {
            "direction": "forward",
            "restrictions": {
              "access": [
                {
                  "access_type": "allowed",
                  "when": {
                    "mode": [
                      "hov"
                    ]
                  }
                }
              ],
              "min_occupancy": 3
            }
          },
          {
            "direction": "forward"
          },
          {
            "direction": "forward"
          }
        ]
      }
    ],
    "speed_limits": [
      {
        "max_speed": {
          "value": 100,
          "unit": "km/h"
        }
      }
    ]
  }
}

Access Restrictions

{
  "id": "overture:transportation:example:simple-road1",
  "type": "Feature",
  "geometry": {
    "type": "LineString",
    "coordinates": [
      [
        -122.152944,
        47.629681
      ],
      [
        -122.152916,
        47.629686
      ],
      [
        -122.152501,
        47.62977
      ],
      [
        -122.152188,
        47.62984
      ],
      [
        -122.151813,
        47.629934
      ],
      [
        -122.151747,
        47.629952
      ]
    ]
  },
  "properties": {
    "theme": "transportation",
    "type": "segment",
    "version": 4,
    "subtype": "road",
    "class": "motorway",
    "connector_ids": [
      "fooConnector",
      "barConnector"
    ],
    "connectors": [
      {
        "connector_id": "fooConnector",
        "at": 0
      },
      {
        "connector_id": "barConnector",
        "at": 1
      }
    ],
    "names": {
      "primary": "SR 520"
    },
    "access_restrictions": [
      {
        "access_type": "denied",
        "when": {
          "mode": [
            "foot"
          ]
        }
      }
    ]
  }
}

Turn Restrictions

This example illustrates a complex via type turn restriction across three connected segments. When traveling forward along the source segment, the transition to the target segment is not allowed to go through the via segment.

Source segment

{
  "id": "overture:transportation:example:via-turn-restriction-source",
  "type": "Feature",
  "geometry": {
    "type": "LineString",
    "coordinates": [
      [
        -71.1100226929593,
        42.30156668552357
      ],
      [
        -71.11055493812631,
        42.30157222996385
      ],
      [
        -71.11102971081017,
        42.30157407811038
      ],
      [
        -71.11143701579662,
        42.30156114108277
      ],
      [
        -71.11197425857047,
        42.30152602627953
      ],
      [
        -71.11234408150312,
        42.30149091145671
      ],
      [
        -71.1126589307566,
        42.30147612626226
      ],
      [
        -71.11301376086777,
        42.301494607754876
      ],
      [
        -71.11320616874515,
        42.301516785538524
      ]
    ]
  },
  "properties": {
    "theme": "transportation",
    "type": "segment",
    "version": 5,
    "subtype": "road",
    "class": "primary",
    "connector_ids": [
      "overture:transportation:example:via-turn-restriction-connector1",
      "overture:transportation:example:via-turn-restriction-connector2"
    ],
    "connectors": [
      {
        "connector_id": "overture:transportation:example:via-turn-restriction-connector1",
        "at": 0
      },
      {
        "connector_id": "overture:transportation:example:via-turn-restriction-connector2",
        "at": 1
      }
    ],
    "names": {
      "primary": "Arborway"
    },
    "prohibited_transitions": [
      {
        "sequence": [
          {
            "segment_id": "overture:transportation:example:via-turn-restriction-target",
            "connector_id": "overture:transportation:example:via-turn-restriction-connector2"
          },
          {
            "segment_id": "overture:transportation:example:via-turn-restriction-via",
            "connector_id": "overture:transportation:example:via-turn-restriction-connector1"
          }
        ],
        "final_heading": "forward",
        "when": {
          "heading": "forward",
          "during": "Mo-Fr 06:00-09:00, 15:00-19:00"
        }
      }
    ],
    "road_surface": [
      {
        "value": "paved"
      }
    ]
  }
}

Connector 1

{
  "id": "overture:transportation:example:via-turn-restriction-connector1",
  "type": "Feature",
  "geometry": {
    "type": "Point",
    "coordinates": [
      -71.11234408150312,
      42.30149091145671
    ]
  },
  "properties": {
    "theme": "transportation",
    "type": "connector",
    "version": 1
  }
}

Via segment

{
  "id": "overture:transportation:example:simple-road2",
  "type": "Feature",
  "geometry": {
    "type": "LineString",
    "coordinates": [
      [
        -71.11213418200086,
        42.3017182333833
      ],
      [
        -71.11234408150312,
        42.30149091145671
      ],
      [
        -71.11248901211202,
        42.3013264259736
      ],
      [
        -71.11283634581244,
        42.30093831245662
      ]
    ]
  },
  "properties": {
    "theme": "transportation",
    "type": "segment",
    "version": 5,
    "subtype": "road",
    "class": "secondary",
    "connector_ids": [
      "overture:transportation:example:via-turn-restriction-connector1",
      "overture:transportation:example:via-turn-restriction-connector2"
    ],
    "connectors": [
      {
        "connector_id": "overture:transportation:example:via-turn-restriction-connector1",
        "at": 0
      },
      {
        "connector_id": "overture:transportation:example:via-turn-restriction-connector2",
        "at": 1
      }
    ],
    "names": {
      "primary": "Washington Street"
    },
    "road_surface": [
      {
        "value": "paved"
      }
    ]
  }
}

Connector 2

{
  "id": "overture:transportation:example:via-turn-restriction-connector2",
  "type": "Feature",
  "geometry": {
    "type": "Point",
    "coordinates": [
      -71.11248901211202,
      42.3013264259736
    ]
  },
  "properties": {
    "theme": "transportation",
    "type": "connector",
    "version": 1
  }
}

Target segment

{
  "id": "overture:transportation:example:turn-restriction-target",
  "type": "Feature",
  "geometry": {
    "type": "LineString",
    "coordinates": [
      [
        -71.11325364601365,
        42.301374477956756
      ],
      [
        -71.11278137213321,
        42.3013264259736
      ],
      [
        -71.11248901211202,
        42.3013264259736
      ],
      [
        -71.11157195119078,
        42.30139295947919
      ],
      [
        -71.1109997251666,
        42.301428074356636
      ],
      [
        -71.11058492376937,
        42.30143177065813
      ],
      [
        -71.11002519176327,
        42.301415137298676
      ]
    ]
  },
  "properties": {
    "theme": "transportation",
    "type": "segment",
    "version": 5,
    "subtype": "road",
    "class": "primary",
    "connector_ids": [
      "overture:transportation:example:via-turn-restriction-connector1",
      "overture:transportation:example:via-turn-restriction-connector2"
    ],
    "connectors": [
      {
        "connector_id": "overture:transportation:example:via-turn-restriction-connector1",
        "at": 0
      },
      {
        "connector_id": "overture:transportation:example:via-turn-restriction-connector2",
        "at": 1
      }
    ],
    "names": {
      "primary": "Arborway"
    },
    "road_surface": [
      {
        "value": "paved"
      }
    ]
  }
}