create_two_lane_map Namespace Reference

Functions
def	add_node (x, y, z=0.0)
def	create_way (node_ids, tags)
def	create_lanelet (left_id, right_id, tags)
def	create_vector_map (filename, total_length, lane_width, points_per_meter)

Variables
string	geo_reference = "+proj=tmerc +lat_0=0 +lon_0=0 +k=1 +x_0=0 +y_0=0 +datum=WGS84 +units=m +no_defs"
	proj = Proj(geo_reference)
	transformer = Transformer.from_proj(proj, "epsg:4326", always_xy=True)
int	node_id = 1000000
int	way_id = 1000
int	relation_id = 100
	nodes
	ways
	relations
	parser = argparse.ArgumentParser(description="Create a vector map with two parallel lanes.")
	type
	str
	default
	help
	float
	int
	args = parser.parse_args()

Detailed Description

This script creates a vector map with two parallel lanes using the Lanelet2 library and saves it as an OSM file.
The script can be run from the command line with the following arguments:
- filename: The output filename for the vector map.
- total_length: The length of the lanes (default is 50.0).
- lane_width: The width of the lanes (default is 3.7).
- points_per_meter: The number of points per meter (default is 5).

Dependencies:
- lanelet2: The Lanelet2 library for handling lanelet maps.
- argparse: For parsing command line arguments.
Usage:
    python3 create_two_lane_map.py --filename output.osm --total_length <total_length> --lane_width <lane_width> --points_per_meter <points_per_meter>

Function Documentation

add_node()

def create_two_lane_map.add_node	(		x,
			y,
			z = 0.0
	)

Definition at line 35 of file create_two_lane_map.py.

def add_node(x, y, z=0.0):
    global node_id
    lon, lat = transformer.transform(x, y)
    node = ET.Element("node", id=str(node_id), version="1", lat=f"{lat:.9f}", lon=f"{lon:.9f}", visible="true")
    ET.SubElement(node, "tag", k="ele", v=f"{z:.2f}")
    ET.SubElement(node, "tag", k="lat", v=f"{lat:.9f}")
    ET.SubElement(node, "tag", k="lon", v=f"{lon:.9f}")
    nodes.append((node_id, node))
    node_id += 1
    return node_id - 1
 

References str.

Referenced by create_vector_map().

Here is the caller graph for this function:

create_lanelet()

def create_two_lane_map.create_lanelet	(		left_id,
			right_id,
			tags
	)

Definition at line 57 of file create_two_lane_map.py.

def create_lanelet(left_id, right_id, tags):
    global relation_id
    rel = ET.Element("relation", id=str(relation_id), version="1", visible="true")
    ET.SubElement(rel, "member", type="way", ref=str(left_id), role="left")
    ET.SubElement(rel, "member", type="way", ref=str(right_id), role="right")
    for k, v in tags.items():
        ET.SubElement(rel, "tag", k=k, v=v)
    ET.SubElement(rel, "tag", k="cad_id", v=str(relation_id))
    relations.append((relation_id, rel))
    relation_id += 1
 

References str.

Referenced by create_vector_map().

Here is the caller graph for this function:

create_vector_map()

def create_two_lane_map.create_vector_map	(		filename,
			total_length,
			lane_width,
			points_per_meter
	)

Create a vector map with two parallel lanes.
Inputs:
- filename: The output filename for the vector map.
- total_length: The length of the lanes.
- lane_width: The width of the lanes.
- points_per_meter: The number of points per meter.

Definition at line 68 of file create_two_lane_map.py.

def create_vector_map(filename, total_length, lane_width, points_per_meter):
    """
    Create a vector map with two parallel lanes.
    Inputs:
    - filename: The output filename for the vector map.
    - total_length: The length of the lanes.
    - lane_width: The width of the lanes.
    - points_per_meter: The number of points per meter.
    """
    # Road geometry
    lanelet_length = 25.0
    total_points = int(total_length * points_per_meter) + 1
    points_per_lanelet = int(lanelet_length * points_per_meter) + 1
    # Generate lane boundaries
    x_offset = -total_length / 2
    y_offset = -lane_width
    left1, right1, left2, right2 = [], [], [], []
    for i in range(total_points):
        x = i / points_per_meter + x_offset
        right1.append(add_node(x, 0 + y_offset))
        left1.append(add_node(x, lane_width + y_offset))
        right2.append(add_node(x, lane_width + y_offset))
        left2.append(add_node(x, 2 * lane_width + y_offset))
 
    stride = points_per_lanelet - 1
    way_dict = {"type": "line_thin", "subtype": "solid"}
    lanelet_dict = {"type": "lanelet",
                    "subtype": "road",
                    "road_type": "road",
                    "turn_direction": "straight",
                    "from_cad_id" : [],
                    "direction" : "ONE_WAY",
                    "level" : "0",
                    "location" : "private",
                    "near_spaces" : [],
                    "participant:vehicle" : "yes",
                    "to_cad_id" : [],
                    }
    for i in range(0, total_points - stride, stride):
         # Outer left boundary of lane 2
        l2_nodes = left2[i:i + points_per_lanelet]
        l2_id = create_way(l2_nodes, way_dict)  # solid
 
        # Shared dashed centerline between lanes
        center_nodes = right2[i:i + points_per_lanelet]
        center_id = create_way(center_nodes, {"type": "line_thin", "subtype": "dashed"})
 
        # Outer right boundary of lane 1
        r1_nodes = right1[i:i + points_per_lanelet]
        r1_id = create_way(r1_nodes, way_dict)  # solid
 
        # Lanelet for lane 2 (left: outer left, right: dashed center)
        create_lanelet(l2_id, center_id, lanelet_dict)
 
        # Lanelet for lane 1 (left: dashed center, right: outer right)
        create_lanelet(center_id, r1_id, lanelet_dict)
 
    # Build OSM XML tree
    osm = ET.Element("osm", version="0.6")
    ET.SubElement(osm, "geoReference", v=geo_reference)
    for _, node in nodes:
        osm.append(node)
    for _, way in ways:
        osm.append(way)
    for _, rel in relations:
        osm.append(rel)
 
    # Write to file
    with open(filename, "w", encoding="utf-8") as f:
        xml_str = minidom.parseString(ET.tostring(osm)).toprettyxml(indent="  ")
        f.write(xml_str)
 
    print(f"Map saved to {filename}")
 

References add_node(), create_lanelet(), create_way(), and int.

Here is the call graph for this function:

create_way()

def create_two_lane_map.create_way	(		node_ids,
			tags
	)

Definition at line 46 of file create_two_lane_map.py.

def create_way(node_ids, tags):
    global way_id
    way = ET.Element("way", id=str(way_id), version="1", visible="true")
    for nid in node_ids:
        ET.SubElement(way, "nd", ref=str(nid))
    for k, v in tags.items():
        ET.SubElement(way, "tag", k=k, v=v)
    ways.append((way_id, way))
    way_id += 1
    return way_id - 1
 

References str.

Referenced by create_vector_map().

Here is the caller graph for this function:

Variable Documentation

args

create_two_lane_map.args = parser.parse_args()

Definition at line 148 of file create_two_lane_map.py.

default

create_two_lane_map.default

Definition at line 144 of file create_two_lane_map.py.

float

create_two_lane_map.float

Definition at line 145 of file create_two_lane_map.py.

Referenced by mobilitypath_visualizer::MobilityPathVisualizer.composeVisualizationMarker(), and RouteCreation_CSV2Yaml.convertCSVToRouteFile().

geo_reference

string create_two_lane_map.geo_reference = "+proj=tmerc +lat_0=0 +lon_0=0 +k=1 +x_0=0 +y_0=0 +datum=WGS84 +units=m +no_defs"

Definition at line 23 of file create_two_lane_map.py.

help

create_two_lane_map.help

Definition at line 144 of file create_two_lane_map.py.

int

create_two_lane_map.int

Definition at line 147 of file create_two_lane_map.py.

Referenced by speedharm_auto_configure.assign_algorithm(), speedharm_auto_configure.assign_experiment(), route::RouteGeneratorWorker.composeRouteMarkerMsg(), RouteCreation_CSV2Yaml.convertCSVToRouteFile(), create_vector_map(), platooning_strategic_ihp::PlatooningManager.getDynamicLeader(), guidance::GuidanceWorker.handle_on_activate(), route::Route.handle_on_activate(), process_traj_logs.index_plot_with_slider(), process_bag.index_plot_with_slider(), sci_strategic_plugin::SCIStrategicPlugin.plan_maneuvers_callback(), speedharm-cli.process_assign_algorithm(), speedharm-cli.process_assign_experiment(), and process_traj_logs.xy_scatter_with_slider().

node_id

int create_two_lane_map.node_id = 1000000

Definition at line 30 of file create_two_lane_map.py.

nodes

create_two_lane_map.nodes

Definition at line 33 of file create_two_lane_map.py.

parser

create_two_lane_map.parser = argparse.ArgumentParser(description="Create a vector map with two parallel lanes.")

Definition at line 143 of file create_two_lane_map.py.

proj

create_two_lane_map.proj = Proj(geo_reference)

Definition at line 26 of file create_two_lane_map.py.

relation_id

int create_two_lane_map.relation_id = 100

Definition at line 32 of file create_two_lane_map.py.

relations

create_two_lane_map.relations

Definition at line 33 of file create_two_lane_map.py.

Referenced by route_following_plugin::RouteFollowingPlugin.isLaneChangeNeeded().

str

create_two_lane_map.str

Definition at line 144 of file create_two_lane_map.py.

Referenced by add_node(), create_lanelet(), carma_src.create_ros2_tracing_action(), create_way(), environment.generate_launch_description(), approaching_emergency_vehicle_plugin::ApproachingEmergencyVehiclePlugin.generateApproachingErvStatusMessage(), process_bag.index_plot_with_slider(), speedharm_auto_configure.log(), speedharm_auto_configure.main(), ros2_rosbag.record_ros2_rosbag(), reindex_active_rosbags.reindex_bag_files(), lanelet::MapConformer::anonymous_namespace{MapConformer.cpp}.startswith(), traffic_incident_parser::TrafficIncidentParserWorker.stringParserHelper(), carma_cooperative_perception.to_detection_list_msg(), and RouteCreation_CSV2Yaml.waypointAsYAMLString().

transformer

create_two_lane_map.transformer = Transformer.from_proj(proj, "epsg:4326", always_xy=True)

Definition at line 27 of file create_two_lane_map.py.

type

create_two_lane_map.type

Definition at line 144 of file create_two_lane_map.py.

Referenced by frame_transformer::Node.build_transformer(), lanelet::MapConformer::anonymous_namespace{MapConformer.cpp}.buildControlLine(), route_following_plugin::RouteFollowingPlugin.bumper_pose_cb(), platooning_strategic_ihp::PlatooningStrategicIHPPlugin.composeMobilityOperationLeader(), platooning_strategic_ihp::PlatooningStrategicIHPPlugin.composeMobilityOperationLeadWithOperation(), lanelet::MapConformer::anonymous_namespace{MapConformer.cpp}.getChangeType(), and arbitrator.maneuver_type_to_string().

way_id

int create_two_lane_map.way_id = 1000

Definition at line 31 of file create_two_lane_map.py.

ways

create_two_lane_map.ways

Definition at line 33 of file create_two_lane_map.py.