Exemple #1
0
  def test_configurable_scenario_generation_default_params(self):
    params = ParameterServer()
    scenario_generation = ConfigurableScenarioGeneration(num_scenarios=2,params=params)
    scenario_generation.dump_scenario_list("test.scenario")

    scenario_loader = ScenarioGeneration()
    scenario_loader.load_scenario_list("test.scenario")

    self.assertEqual(len(scenario_loader._scenario_list), 2)
    self.assertEqual(len(scenario_loader._scenario_list[0]._agent_list), len(scenario_generation._scenario_list[0]._agent_list))

    scenario = scenario_loader.get_scenario(idx=0)

    params.save("default_params.json")
Exemple #2
0
  def test_find_overlaps_configurable_scenario_generation(self):
    shape = Polygon2d([0, 0, 0], [Point2d(-1,0),
                      Point2d(-1,1),
                      Point2d(1,1),
                      Point2d(1,0)])

    agent_states1 = [[0, 1, 0, 0, 0], [0, 4, 0, 0, 0], [0, 8, 0, 0, 0]] # agents along x axis
    agent_geometries1 = [shape, shape, shape]

    agent_states2 = [[0, 4, -10, 0, 0], [0, 4, 0, 0, 0], [0, 4, 20, 0, 0]] # agents along y axis at x= 4
    agent_geometries2 = [shape, shape, shape]

    agent_states3 = [[0, 20, -20, 0, 0], [0, 1, 0, 0, 0], [0, 4, 20, 0, 0]] # some agents two colliding with other configs
    agent_geometries3 = [shape, shape, shape]

    collected_sources_sinks_agent_states_geometries = [(agent_states1, agent_geometries1),
                                                  (agent_states2, agent_geometries2),
                                                  (agent_states3, agent_geometries3)]
    
    overlaps = ConfigurableScenarioGeneration.find_overlaps_in_sources_sinks_agents( 
                  collected_sources_sinks_agent_states_geometries)


    self.assertTrue("0-1" in overlaps)
    
    collisions_01 = overlaps["0-1"]
    self.assertEqual(len(collisions_01), 1)

    # check source sink configs
    self.assertEqual(collisions_01[0][0][0], 0)
    self.assertEqual(collisions_01[0][1][0], 1)

    #check agent positions in list
    self.assertEqual(collisions_01[0][0][1], 1)
    self.assertEqual(collisions_01[0][1][1], 1)
    
    self.assertTrue("0-2" in overlaps)
    
    collisions_02 = overlaps["0-2"]
    self.assertEqual(len(collisions_02), 1)

    # check source sink configs
    self.assertEqual(collisions_02[0][0][0], 0)
    self.assertEqual(collisions_02[0][1][0], 2)

    #check agent positions in list
    self.assertEqual(collisions_02[0][0][1], 0)
    self.assertEqual(collisions_02[0][1][1], 1)

    collisions_03 = overlaps["1-2"]
    self.assertEqual(len(collisions_03), 1)

    # check source sink configs
    self.assertEqual(collisions_03[0][0][0], 1)
    self.assertEqual(collisions_03[0][1][0], 2)

    #check agent positions in list
    self.assertEqual(collisions_03[0][0][1], 2)
    self.assertEqual(collisions_03[0][1][1], 2)
    def _build_configuration(self):
        """Builds a configuration using an SAC agent
    """
        # TODO(@hart): increase scenario number
        self._scenario_generator = \
          ConfigurableScenarioGeneration(num_scenarios=100,
                                         params=self._params)

        # USE THIS FOR DETERMINISTIC SCENARIO GEN.
        # self._scenario_generator = \
        #   DeterministicScenarioGeneration(num_scenarios=100,
        #                                   params=self._params)
        # self._observer = NearestObserver(self._params)
        self._observer = ClosestAgentsObserver(self._params)

        self._behavior_model = DynamicModel(params=self._params)
        self._evaluator = CustomEvaluator(params=self._params)
        sim_step_time = 0.2
        real_time_factor = 5

        resolution = (1920, 1080)
        dpi = 300
        fig_env = plt.figure(figsize=(resolution[0] / dpi,
                                      resolution[1] / dpi),
                             dpi=dpi)
        gs = gridspec.GridSpec(1, 1, left=0.0, right=1, bottom=0, top=0.9)
        axis = plt.subplot(gs[0])
        viewer = MPViewer(params=self._params,
                          y_length=80,
                          enforce_y_length=True,
                          enforce_x_length=False,
                          follow_agent_id=True,
                          axis=axis)
        # self._viewer = VideoRenderer(renderer=viewer, world_step_time=0.2)
        self._viewer = viewer
        self._runtime = RuntimeRL(action_wrapper=self._behavior_model,
                                  observer=self._observer,
                                  evaluator=self._evaluator,
                                  step_time=0.2,
                                  viewer=self._viewer,
                                  scenario_generator=self._scenario_generator)
        tfa_env = tf_py_environment.TFPyEnvironment(TFAWrapper(self._runtime))
        eval_tf_env = tf_py_environment.TFPyEnvironment(
            TFAWrapper(self._runtime))
        # self._agent = PPOAgent(tfa_env, params=self._params)
        # self._runner = PPORunner(tfa_env,
        #                          eval_tf_env,
        #                          self._agent,
        #                          params=self._params,
        #                          unwrapped_runtime=self._runtime)
        self._agent = SACAgent(tfa_env, params=self._params)
        self._runner = SACRunner(tfa_env,
                                 self._agent,
                                 params=self._params,
                                 unwrapped_runtime=self._runtime)
    def test_configurable_scenario_generation_sample_behavior_types(self):
        sink_source_dict = [{
            "SourceSink": [[5111.626, 5006.8305], [5110.789, 5193.1725]],
            "Description":
            "left_lane",
            "ConfigAgentStatesGeometries": {
                "Type": "UniformVehicleDistribution",
                "LanePositions": [0]
            },
            "ConfigBehaviorModels": {
                "Type": "FixedBehaviorType",
                "ModelType": "BehaviorIDMClassic",
                "ModelParams": {
                    "BehaviorIDMClassic::MaxVelocity": 60.0
                }
            },
            "ConfigExecutionModels": {
                "Type": "FixedExecutionType"
            },
            "ConfigDynamicModels": {
                "Type": "FixedDynamicType"
            },
            "ConfigGoalDefinitions": {
                "Type": "FixedGoalTypes"
            },
            "ConfigControlledAgents": {
                "Type": "NoneControlled"
            },
            "AgentParams": {}
        }, {
            "SourceSink": [[5111.626, 5006.8305], [5110.789, 5193.1725]],
            "Description":
            "right_lane",
            "ConfigAgentStatesGeometries": {
                "Type": "UniformVehicleDistribution",
                "LanePositions": [1]
            },
            "ConfigBehaviorModels": {
                "Type": "SampleBehaviorType"
            },
            "ConfigExecutionModels": {
                "Type": "FixedExecutionType"
            },
            "ConfigDynamicModels": {
                "Type": "FixedDynamicType"
            },
            "ConfigGoalDefinitions": {
                "Type": "FixedGoalTypes"
            },
            "ConfigControlledAgents": {
                "Type": "RandomSingleAgent"
            },
            "AgentParams": {}
        }]
        params = ParameterServer()
        params["Scenario"]["Generation"]["ConfigurableScenarioGeneration"][
            "SinksSources"] = sink_source_dict
        scenario_generation = ConfigurableScenarioGeneration(num_scenarios=2,
                                                             params=params)
        scenario_generation.dump_scenario_list("test.scenario")

        params.save("default_params_behavior_type_sampling.json")
    def test_find_overlaps_configurable_scenario_generation(self):
        shape = Polygon2d(
            [0, 0, 0],
            [Point2d(-1, 0),
             Point2d(-1, 1),
             Point2d(1, 1),
             Point2d(1, 0)])

        agent_states1 = [[0, 1, 0, 0, 0], [0, 4, 0, 0, 0],
                         [0, 8, 0, 0, 0]]  # agents along x axis
        agent_geometries1 = [shape, shape, shape]

        agent_states2 = [[0, 4, -10, 0, 0], [0, 4, 0, 0, 0],
                         [0, 4, 20, 0, 0]]  # agents along y axis at x= 4
        agent_geometries2 = [shape, shape, shape]

        # some agents two colliding with other configs
        agent_states3 = [[0, 20, -20, 0, 0], [0, 1, 0, 0, 0], [0, 4, 20, 0, 0]]
        agent_geometries3 = [shape, shape, shape]

        collected_sources_sinks_agent_states_geometries = [
            (agent_states1, agent_geometries1),
            (agent_states2, agent_geometries2),
            (agent_states3, agent_geometries3)
        ]

        overlaps = ConfigurableScenarioGeneration.find_overlaps_in_sources_sinks_agents(
            collected_sources_sinks_agent_states_geometries)

        self.assertTrue("0-1" in overlaps)

        collisions_01 = overlaps["0-1"]
        self.assertEqual(len(collisions_01), 1)

        # check source sink configs
        self.assertEqual(collisions_01[0][0][0], 0)
        self.assertEqual(collisions_01[0][1][0], 1)

        # check agent positions in list
        self.assertEqual(collisions_01[0][0][1], 1)
        self.assertEqual(collisions_01[0][1][1], 1)

        self.assertTrue("0-2" in overlaps)

        collisions_02 = overlaps["0-2"]
        self.assertEqual(len(collisions_02), 1)

        # check source sink configs
        self.assertEqual(collisions_02[0][0][0], 0)
        self.assertEqual(collisions_02[0][1][0], 2)

        # check agent positions in list
        self.assertEqual(collisions_02[0][0][1], 0)
        self.assertEqual(collisions_02[0][1][1], 1)

        collisions_03 = overlaps["1-2"]
        self.assertEqual(len(collisions_03), 1)

        # check source sink configs
        self.assertEqual(collisions_03[0][0][0], 1)
        self.assertEqual(collisions_03[0][1][0], 2)

        # check agent positions in list
        self.assertEqual(collisions_03[0][0][1], 2)
        self.assertEqual(collisions_03[0][1][1], 2)

        def test_dataset_scenario_generation(self):
            params = ParameterServer()

            map_filename = "modules/runtime/tests/data/DR_DEU_Merging_MT_v01_shifted.xodr"
            track_filename = "modules/runtime/tests/data/interaction_dataset_dummy_track.csv"

            params["Scenario"]["Generation"][
                "InteractionDatasetScenarioGenerationFull"][
                    "MapFilename"] = map_filename
            params["Scenario"]["Generation"][
                "InteractionDatasetScenarioGenerationFull"][
                    "TrackFilename"] = track_filename

            scenario_generation = InteractionDatasetScenarioGenerationFull(
                params=params, num_scenarios=2)
# https://opensource.org/licenses/MIT




from modules.runtime.scenario.scenario_generation.configurable_scenario_generation import ConfigurableScenarioGeneration
from modules.runtime.commons.parameters import ParameterServer
from modules.runtime.viewer.matplotlib_viewer import MPViewer
from modules.runtime.runtime import Runtime
from modules.runtime.viewer.pygame_viewer import PygameViewer
import time
import os

scenario_param_file ="highway_merge_configurable.json" # must be within examples params folder
param_server = ParameterServer(filename= os.path.join("examples/params/",scenario_param_file))
scenario_generation = ConfigurableScenarioGeneration(num_scenarios=3, params=param_server)

viewer = MPViewer(
  params=param_server,
  x_range=[5060, 5160],
  y_range=[5070,5150],
  use_world_bounds=True)
sim_step_time = param_server["simulation"]["step_time",
                                           "Step-time used in simulation",
                                           0.2]
sim_real_time_factor = param_server["simulation"]["real_time_factor",
                                                  "execution in real-time or faster",
                                                  1]

env = Runtime(0.2,
              viewer,