simulation.utils.road.renderer package

Submodules

simulation.utils.road.renderer.obstacle module

Functions:

draw(name, obst)
obstacle_model(name, x, y, length, width, …)

draw(name, obst)

obstacle_model(name, x, y, length, width, height, orientation)

simulation.utils.road.renderer.surface_markings module

Functions:

draw(ctx, surface_marking)
draw_speed_limit(ctx, surface_marking, …)	Draw a speed limit on the road.
draw_start_lane(ctx, frame)	Draw the checkerboard pattern to mark the beginning of a parking area in the given frame.
draw_blocked_area(ctx, frame)	Draw a blocked area in the given frame.
draw_zebra_crossing(ctx, frame[, …])	Draw a zebra crossing in the given frame.
draw_crossing_lines(ctx, frame)	Draw a crossing area for pedestrian, which is only marked by dashed lines, in the given frame.
draw_traffic_island_blocked(ctx, frame)	Draw a blocked area, which splits the two lanes of the traffic island, in the given frame.
draw_parking_spot_x(ctx, frame)	Draw two crossing lines (X) in the given frame to represent a blocked spot.
draw_blocked_stripes(ctx, v, start, line, …)	Draw white stripes onto the ground.

draw(ctx, surface_marking: simulation.utils.road.sections.surface_marking.SurfaceMarking)

draw_speed_limit(ctx: cairo.Context, surface_marking: simulation.utils.road.sections.surface_marking.SurfaceMarking, limit: int, start_zone: bool)

Draw a speed limit on the road. Add a cross if it is the end of a speed limit zone.

Parameters

start_zone – Is this speed limit the start or end?

draw_start_lane(ctx, frame: simulation.utils.geometry.polygon.Polygon)

Draw the checkerboard pattern to mark the beginning of a parking area in the given frame.

Parameters

frame – Frame of the start lane. Points of the frame must be given in the right order! first point : start on left line second point: end on left line third point : end on right line fourth point: start on right line

draw_blocked_area(ctx, frame: simulation.utils.geometry.polygon.Polygon)

Draw a blocked area in the given frame.

Parameters

frame –

Frame of the blocked area. Points of the frame must be given in the right order! first point : start on right line second point: left of first point, towards middle line third point : left of fourth point, towards middle line fourth point: end on right line

Line between second and third point has to be parallel to middle/right line.

draw_zebra_crossing(ctx, frame: simulation.utils.geometry.polygon.Polygon, stripe_width: float = 0.04, offset: float = 0.02)

Draw a zebra crossing in the given frame.

Parameters

frame – Frame of the zebra crossing. Points of the frame must be given in the right order! first point : start on left line second point: end on left line third point : end on right line fourth point: start on right line

draw_crossing_lines(ctx, frame: simulation.utils.geometry.polygon.Polygon)

Draw a crossing area for pedestrian, which is only marked by dashed lines, in the given frame.

The dashed lines are perpendicular to the road.

Parameters

frame – Frame of the crossing area. Points of the frame must be given in the right order! first point : start on left line second point: end on left line third point : end on right line fourth point: start on right line

draw_traffic_island_blocked(ctx, frame: simulation.utils.geometry.polygon.Polygon)

Draw a blocked area, which splits the two lanes of the traffic island, in the given frame.

Parameters

frame – Frame of the blocked area. Points of the frame must be given in the right order! first half of points: left border second half: right border

draw_parking_spot_x(ctx, frame: simulation.utils.geometry.polygon.Polygon)

Draw two crossing lines (X) in the given frame to represent a blocked spot.

Parameters

frame – Frame of the parking spot. Points of the frame must be given in the right order! first point : left lower corner of parking spot second point: left upper corner third point : right upper corner fourth point: right lower corner

draw_blocked_stripes(ctx, v: simulation.utils.geometry.vector.Vector, start: simulation.utils.geometry.point.Point, line: simulation.utils.geometry.line.Line, points: List[simulation.utils.geometry.point.Point], angle: float, gap: float)

Draw white stripes onto the ground.

White stripes are e.g. used by to signal areas on the ground where the car is not allowed to drive.

Parameters

• v – Vector along the line where the stripes start points are located.

• start – Start point on the line where the stripes start points are located.

• line – End points of the stripes are on this line.

• points – List of points of the polygon frame.

• angle – Angle of the stripes.

• gap – Gap between the stripes.

simulation.utils.road.renderer.tile module

Classes:

Tile(index, int], size, resolution, …)

Piece of the groundplane with lines used to display road lines on the ground.

class Tile(index: Tuple[int, int], size: simulation.utils.geometry.vector.Vector, resolution: simulation.utils.geometry.vector.Vector, road_folder_name: Optional[str] = None, sections: Dict[int, simulation.utils.road.sections.road_section.RoadSection] = <factory>, id: Optional[str] = None, already_rendered: bool = False)

Bases: object

Piece of the groundplane with lines used to display road lines on the ground.

The groundplane in simulation is made out of many rectangular tiles. Each tile displays an image on the ground.

Attributes:

COUNTER	Static variable used to generate unique model names in Gazebo.
index	Position within the lattice of tiles on the groundplane.
size	Size of the tile.
resolution	Resolution of the tile’s image.
road_folder_name	Name of the folder in which all tiles of the current road are.
sections	All sections that are (atleast partly) on this tile.
id	ID of the tile.
already_rendered	Indicate whether the tile has been rendered before.
name	Name of the tile’s model when spawned in Gazebo.
transform	Transform to the center of the tile.
frame	Frame of the tile.

Methods:

get_material_string()	Content of the tile’s material file.
get_model_string()	Get a model string that can be spawned in Gazebo.
render_to_file(roads_path)	Render an image of the tile and save it to a file.

COUNTER = 0

Static variable used to generate unique model names in Gazebo.

To ensure that Gazebo doesn’t get confused with multiple tiles that have the same name, e.g. when reloading, the counter is increased every time a model name is generated.

index: Tuple[int, int]

Position within the lattice of tiles on the groundplane.

size: simulation.utils.geometry.vector.Vector

Size of the tile.

resolution: simulation.utils.geometry.vector.Vector

Resolution of the tile’s image.

road_folder_name: str = None

Name of the folder in which all tiles of the current road are.

(Not the complete path, just the name of the folder!)

sections: Dict[int, simulation.utils.road.sections.road_section.RoadSection]

All sections that are (atleast partly) on this tile.

id: str = None

ID of the tile.

Automatically generated when rendering.

already_rendered: bool = False

Indicate whether the tile has been rendered before.

property name: str

Name of the tile’s model when spawned in Gazebo.

Type

str

property transform: simulation.utils.geometry.transform.Transform

Transform to the center of the tile.

Type

Transform

property frame: simulation.utils.geometry.polygon.Polygon

Frame of the tile.

Type

Polygon

get_material_string() → str

Content of the tile’s material file.

See: http://gazebosim.org/tutorials?tut=color_model

get_model_string() → str

Get a model string that can be spawned in Gazebo.

render_to_file(roads_path: str)

Render an image of the tile and save it to a file.

Parameters

roads_path – Directory in which all roads are located.

simulation.utils.road.renderer.traffic_sign module

Functions:

draw(name, sign)
model(x, y, z, orientation, name, mesh, …)

draw(name: str, sign: simulation.utils.road.sections.traffic_sign.TrafficSign)

model(x, y, z, orientation, name, mesh, collision_box_position, collision_box_size)

simulation.utils.road.renderer.utils module

Functions:

draw_line(ctx, marked_line[, line_width, …])
_draw_double_line(ctx, line, style_left, …)
draw_polygon(ctx, polygon[, lines])

draw_line(ctx, marked_line: simulation.utils.road.sections.road_section.MarkedLine, line_width: float = 0.02, dash_length: float = 0.2, dash_gap: Optional[float] = None, double_line_gap: float = 0.02)

_draw_double_line(ctx, line: simulation.utils.road.sections.road_section.MarkedLine, style_left: str, style_right: str, line_width: float, double_line_gap: float)

draw_polygon(ctx, polygon: simulation.utils.geometry.polygon.Polygon, lines: Optional[List[bool]] = None)

Module contents