Module examples.xodr.full_junction

scenariogeneration https://github.com/pyoscx/scenariogeneration

This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. If a copy of the MPL was not distributed with this file, You can obtain one at https://mozilla.org/MPL/2.0/.

Copyright (c) 2022 The scenariogeneration Authors.

An example, using the generators, showing how to create different symetric junctions, the numintersections can be changed to create different junctions

In this example we can create a junction given

Some features used:

  • create_road

  • CommonJunctionCreator

Classes

class Scenario
Expand source code 
class Scenario(ScenarioGenerator):
    def __init__(self):
        super().__init__()

    def road(self, **kwargs):
        roads = []
        numintersections = 3
        nlanes = 1

        # setup junction creator
        junction_creator = xodr.CommonJunctionCreator(100, "my junction")

        # create some roads
        for i in range(numintersections):
            roads.append(
                xodr.create_road(
                    [xodr.Line(100)],
                    i,
                    center_road_mark=xodr.std_roadmark_broken(),
                    left_lanes=nlanes,
                    right_lanes=nlanes,
                )
            )

            # add road to junciton
            junction_creator.add_incoming_road_circular_geometry(
                roads[i], 20, i * 2 * np.pi / numintersections, "successor"
            )

            # add connection to all previous roads
            for j in range(i):
                junction_creator.add_connection(j, i)

        odr = xodr.OpenDrive("myroad")

        for r in roads:
            odr.add_road(r)
        odr.add_junction_creator(junction_creator)

        odr.adjust_roads_and_lanes()

        return odr

ScenarioTemplate is a class that should be inherited by a Scenario class in order to generate xodr and xosc files based on the submodules xodr and xosc.

Two main uses, in your generation class define self.parameters as either as: - a dict of lists, where the lists are the values you want to sweep over, all permutations of these sets will be generated - a list of dicts, where the dicts are identical and each element in the list is one scenario

Attributes

road_file : str
name of the roadfile
parameters : dict[list], list[dicts]
parameter sets to be used
naming : str
two options "numerical" or "parameter"
generate_all_roads : bool
will only generate unique roads
number_of_parallel_writings : int
parallelize the writing of the xml files, default: 1
basename : str
basename of the scenariofiles, default: name of file
encoding : str
encoding of the outputs, default: utf-8
excluded_permutations : list[dict]
list of parameter dicts to exclude from generation
expand_permutations : list[dict[list]]
list of dicts where each dict has lists as values, all combinations of these lists will be expanded and combined with the other permutations

Ancestors

Inherited members