def test_road_corridor_forward(self):
        xodr_parser = XodrParser(
            "modules/runtime/tests/data/road_corridor_test.xodr")

        # World Definition
        params = ParameterServer()
        world = World(params)

        map_interface = MapInterface()
        map_interface.SetOpenDriveMap(xodr_parser.map)
        world.SetMap(map_interface)
        open_drive_map = world.map.GetOpenDriveMap()
        viewer = MPViewer(params=params, use_world_bounds=True)

        # Draw map
        viewer.drawWorld(world)
        viewer.show(block=False)

        # Generate RoadCorridor
        roads = [0, 1, 2]
        driving_direction = XodrDrivingDirection.forward
        map_interface.GenerateRoadCorridor(roads, driving_direction)
        road_corridor = map_interface.GetRoadCorridor(roads, driving_direction)

        # Assert road corridor

        # Assert: 3 roads
        self.assertEqual(len(road_corridor.roads), 3)

        # Assert: road1: 2 lanes, road2: 1 lane, road3: 1 lane
        self.assertEqual(len(road_corridor.GetRoad(0).lanes), 3)
        self.assertEqual(len(road_corridor.GetRoad(1).lanes), 2)
        self.assertEqual(len(road_corridor.GetRoad(2).lanes), 3)

        # Assert: next road
        self.assertEqual(road_corridor.GetRoad(0).next_road.road_id, 1)
        self.assertEqual(road_corridor.GetRoad(1).next_road.road_id, 2)

        # Assert: lane links
        self.assertEqual(
            road_corridor.GetRoad(0).GetLane(3).next_lane.lane_id, 5)
        self.assertEqual(
            road_corridor.GetRoad(1).GetLane(5).next_lane.lane_id, 8)

        # Assert: LaneCorridor
        self.assertEqual(len(road_corridor.lane_corridors), 3)

        colors = ["blue", "red", "green"]
        count = 0
        for lane_corridor in road_corridor.lane_corridors:
            viewer.drawPolygon2d(lane_corridor.polygon,
                                 color=colors[count],
                                 alpha=0.5)
            viewer.drawLine2d(lane_corridor.left_boundary, color="red")
            viewer.drawLine2d(lane_corridor.right_boundary, color="blue")
            viewer.drawLine2d(lane_corridor.center_line, color="black")
            viewer.show(block=False)
            plt.pause(2.)
            count += 1
Example #2
0
    def test_two_roads_one_lane(self):
        xodr_map = MakeXodrMapOneRoadTwoLanes()

        # World Definition
        params = ParameterServer()
        world = World(params)

        map_interface = MapInterface()
        map_interface.SetOpenDriveMap(xodr_map)
        world.SetMap(map_interface)
        open_drive_map = world.map.GetOpenDriveMap()
        viewer = MPViewer(params=params, use_world_bounds=True)

        # Draw map
        viewer.drawWorld(world)
        viewer.show(block=False)

        # Generate RoadCorridor
        roads = [100]
        driving_direction = XodrDrivingDirection.forward
        map_interface.GenerateRoadCorridor(roads, driving_direction)
        road_corridor = map_interface.GetRoadCorridor(roads, driving_direction)

        # Assert road corridor

        # Assert: 1 road
        self.assertEqual(len(road_corridor.roads), 1)

        # Assert: road1: 2 lanes
        self.assertEqual(len(road_corridor.GetRoad(roads[0]).lanes), 3)

        colors = ["blue", "red", "green"]
        count = 0
        for lane_corridor in road_corridor.lane_corridors:
            viewer.drawPolygon2d(lane_corridor.polygon,
                                 color=colors[count],
                                 alpha=0.5)
            viewer.drawLine2d(lane_corridor.left_boundary, color="red")
            viewer.drawLine2d(lane_corridor.right_boundary, color="blue")
            viewer.drawLine2d(lane_corridor.center_line, color="black")
            viewer.show(block=False)
            plt.pause(2.)
            count += 1
        viewer.show(block=True)
Example #3
0
    def test_road_corridor_intersection(self):
        xodr_parser = XodrParser(
            "modules/runtime/tests/data/road_corridor_test.xodr")

        # World Definition
        params = ParameterServer()
        world = World(params)

        map_interface = MapInterface()
        map_interface.SetOpenDriveMap(xodr_parser.map)
        world.SetMap(map_interface)
        open_drive_map = world.map.GetOpenDriveMap()
        viewer = MPViewer(params=params, use_world_bounds=True)

        # Draw map
        viewer.drawWorld(world)
        viewer.show(block=False)

        # Generate RoadCorridor
        roads = [0, 1, 2]
        driving_direction = XodrDrivingDirection.forward
        map_interface.GenerateRoadCorridor(roads, driving_direction)

        road_corridor = map_interface.GetRoadCorridor(roads, driving_direction)

        colors = ["blue", "red", "green", "yellow"]
        count = 0

        for road_id, road in road_corridor.roads.items():
            for lane_id, lane in road.lanes.items():
                print(road_id, lane_id, lane.driving_direction)
        for lane_corridor in road_corridor.lane_corridors:
            viewer.drawPolygon2d(lane_corridor.polygon,
                                 color=colors[count],
                                 alpha=0.5)
            viewer.drawLine2d(lane_corridor.left_boundary, color="red")
            viewer.drawLine2d(lane_corridor.right_boundary, color="blue")
            viewer.drawLine2d(lane_corridor.center_line, color="black")
            viewer.show(block=False)
            plt.pause(0.5)
            count += 1
        viewer.show(block=True)
Example #4
0
# XodrLanes of Roadgraph
roadgraph = map_interface.GetRoadgraph()
roadgraph.PrintGraph(output_dir + "/" + map_name)
lane_ids = roadgraph.GetAllLaneids()

for lane_id in lane_ids:
  lane_polygon = roadgraph.GetLanePolygonForLaneId(lane_id)
  # plot plan_view
  road_id = roadgraph.GetRoadForLaneId(lane_id)
  road = map_interface.GetOpenDriveMap().GetRoad(road_id)
  plan_view_reference = road.plan_view.GetReferenceLine()
  # plot polygon with center line
  viewer.drawWorld(world)
  color = list(np.random.choice(range(256), size=3)/256)
  viewer.drawPolygon2d(lane_polygon, color, 1.0)
  viewer.drawLine2d(plan_view_reference, color="red")
  viewer.saveFig(output_dir + "/" + "roadgraph_laneid_" + str(lane_id) + ".png")
  viewer.show(block=True)


#for rc in all_corridors:
#    viewer.drawDrivingCorridor(rc)
#    viewer.saveFig(output_dir + "/" + "test.png")

#
#all_corridors = map_interface.get_all_corridors()
# c = all_corridors[10]
# right_adj_corridors = map_interface.get_adjacent_corridors_same_direction(c, [151, 168, 0.0])
# assert(len(right_adj_corridors) == 2)

# right_adj_corridors = map_interface.get_adjacent_corridors_same_direction(c, [169, 169, 0.0])
Example #5
0
  rc = map_interface.GenerateRoadCorridor(start_p, goal_polygon)
  if rc:
    roads = rc.roads
    road_ids = list(roads.keys())
    print(road_ids, rc.road_ids)
    
    viewer.drawWorld(world)
    viewer.drawRoadCorridor(rc, "blue")
    viewer.saveFig(output_dir + "/" + "roadcorridor_" + str(cnt) + ".png")
    viewer.show()
    viewer.clear()

    for idx, lane_corridor in enumerate(rc.lane_corridors):
      viewer.drawWorld(world)
      viewer.drawLaneCorridor(lane_corridor, "green")
      viewer.drawLine2d(lane_corridor.left_boundary, color="red")
      viewer.drawLine2d(lane_corridor.right_boundary, color="green")
      viewer.drawLine2d(lane_corridor.center_line, color="green")
      viewer.drawPolygon2d(start_polygon, color="green", facecolor="green", alpha=1.)
      viewer.drawPolygon2d(goal_polygon, color="red", facecolor="red", alpha=1.)
      viewer.saveFig(output_dir + "/" + "roadcorridor_" + str(cnt) + "_with_driving_direction_lancecorridor" + str(idx) + ".png")
      viewer.show()
      viewer.clear()
    
    viewer.show()
    viewer.clear()


def DrawRoadCorridor(road_ids, dr=XodrDrivingDirection.forward):
  map_interface.GenerateRoadCorridor(road_ids, dr)
  rc = map_interface.GetRoadCorridor(road_ids, dr)