diff --git a/.gitignore b/.gitignore old mode 100644 new mode 100755 index 07b6e4e..eeed02e --- a/.gitignore +++ b/.gitignore @@ -2,3 +2,7 @@ __pycache__ keyframe_plugin/build keyframe_plugin/CMakeLists.txt.user +world/ +driving-scenario.xml +blender-output +.idea diff --git a/README.md b/README.md old mode 100644 new mode 100755 index 9326be9..3988aa5 --- a/README.md +++ b/README.md @@ -24,6 +24,8 @@ make export GAZEBO_PLUGIN_PATH=`pwd`:$GAZEBO_PLUGIN_PATH ``` +Additionally, install the font located in the commonroad/renderer/fonts subfolder, which is needed to draw speed limit numbers. + ## Usage Generate a random scenario in CommonRoad XML from Template XML: @@ -31,7 +33,9 @@ Generate a random scenario in CommonRoad XML from Template XML: ./road-generator.py presets/driving.xml -o driving-scenario.xml ``` -Render CommonRoad XML for Gazbeo: +Attention: for rendering of the advanced cup track, you will need an installed "Din 1451 Std" font. + +Render CommonRoad XML for Gazebo: ``` ./gazebo-renderer.py driving-scenario.xml -o world @@ -50,3 +54,36 @@ Road generation and rendering can also be done in a single step: ``` ./road-generator.py presets/driving.xml | ./gazebo-renderer.py -o world ``` + +## Blender Renderer + +The Blender renderer automatically converts the intermediate CommonRoad representation and renders keyframe images (currently RGB color and Semantic Segmentation) driving along them. + +Configuration is set via variables in the file ```blender-renderer.py``` as Blender unfortunately does not allow the passing of arguments during script execution. + +Before running, the following packages have to cloned as well: +- drive_gazebo_worlds +- drive_gazebo_sim + +Afterwards, the user has to adjust the ```GAZEBO_WORLDS_PATH``` and ```GAZEBO_SIM_PATH``` variables in the file ```blender-renderer.py``` to point to the root folders of the packages, respectively. + +The variable ```INPUT_PATH``` has to point to the intermediate CommonRoad file generated as described above by ```road-generator.py ```. + +Additional configuration options are available: +- ```OUTPUT_DIR``` : output directory (default: ```./blender-output```) +- ```FORCE_OUTPUT``` : overwrite existing files if output folder exists (default: ```True```) +- ```ADD_VEHICLE``` : render ego-vehicle (default: ```True```) + +Finally, the renderer can the be run using: +``` +bash ./generate_blender_env.sh +``` + +We have tested it using Blender 2.79. Images are rendered in the resolution of 1280 x 800 (corresponding to the Intel RealSense D435 camera). Output images are uncompressed .png (this might require a large amount of free memory for larger sequences). The RGB images are found in ```OUTPUT_DIR/rgb``` Semantic Segmentation images inside ```OUTPUT_DIR/semseg_color```. The label mapping for the Semantic Segmentation images can be found in ```./blender/renderer/segmentation_colormap.py```. + +Two separate scenes are created within the Blender file, one for the RGB image and one for the Semantic Segmentation ground truth. + +The RGB image is rendered using the Cycles Renderer (warning, this might be quite computationally expensive, especially if done on the CPU). It uses a HDRI skydome image in order to introduce a reasonably realistic ambient lighting and background. The background is configured via dicts found in ```blender/renderer/env_configs.py```. +The user has to specify the HDRI image filepath (we have rendered using 2K images) as well as the default orientation and scale of the skybox dome (this can be calibrated empirically using the Cycles background view in the viewport and the background node editor). + +The Semantic Segmentation ground truth images are rendered using the internal Blender renderer. Mipmaps are disabled on the ground plane materials in order to prevent blurry artifcats from appearing on faraway roads. \ No newline at end of file diff --git a/__init__.py b/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/bachelor-thesis/main.pdf b/bachelor-thesis/main.pdf old mode 100644 new mode 100755 diff --git a/bachelor-thesis/presentation.pdf b/bachelor-thesis/presentation.pdf old mode 100644 new mode 100755 diff --git a/bachelor-thesis/videos/driving_static_obstacles.mp4 b/bachelor-thesis/videos/driving_static_obstacles.mp4 old mode 100644 new mode 100755 diff --git a/bachelor-thesis/videos/parking.mp4 b/bachelor-thesis/videos/parking.mp4 old mode 100644 new mode 100755 diff --git a/blender-renderer.py b/blender-renderer.py new file mode 100644 index 0000000..727790a --- /dev/null +++ b/blender-renderer.py @@ -0,0 +1,78 @@ +#!/usr/bin/env python3 +import sys +import os +import shutil +import json +# because blender does not want to have it otherwise -__- +sys.path.append(os.getcwd()) +sys.path += ['/usr/local/lib/python3.5/dist-packages', '/usr/lib/python3/dist-packages', + '/usr/lib/python3.5/dist-packages'] +from blender.renderer.blender import generate_blend + +OUTPUT_DIR = '/data_2/synthetic_data/rendered_scenes/new_cameras/industrial-pipe-1-with-jitter' # output directory +FORCE_OUTPUT = True # overwrite output if True +ADD_VEHICLE = True # render ego-vehicle in the frames +INPUT_FILE = 'driving-scenario.xml' # input CommonRoad file +GAZEBO_WORLDS_PATH = '../drive_gazebo_worlds' # location of the drive_gazebo_worlds package +GAZEBO_SIM_PATH = '../drive_gazebo_sim' # location of the drive_gazebo_sim package + + +# blender does not less us parse arguments +config = {'render_interval_distance': 0.05, + 'groundplane_shader_type': 'ShaderNodeBsdfGlossy', + 'env_config': 'industrial_pipe', + 'texture_padding_ratio': 1.0, + # choose camera to render from, available: realsense, top + # available: RGB (cycles render image), semseg_color (semantic segmentation colormap) + # instances (id map of traffic signs (including poles)), lanes (DRIVABLE lane segmentation, only left/right) + 'render_passes': ['rgb', 'semseg_color', 'instances', 'lanes'], + # resolution provided separately for each camera + 'frame_range': (0, -1), + # use a .png to render the vehicle -> has to be re-generated for each camera position + 'use_vehicle_mask': True, + 'add_random_jitter': True, + "random_jitter": {'x': 0.05, 'y': 0.05, 'angle': 25}, # angle in degrees + 'cameras': [{'name': 'top', + 'position_offset': {'x': -0.126113, 'y': 0, 'z': 0.231409}, + # rotation of the cameras around the Y axis (lateral car axis) in degrees + 'rotation': 31, + 'image_resolution': (2048, 1536), + # used if camera_mask is set to True + 'segmentation_mask': 'top_segmentation_mask.png', + 'sensor_width': 7.18, # 1/1.8 inch on IDS camera + 'sensor_height': 5.32, # 1/1.8 inch on IDS camera + 'focal_length': 1.7, # 1.7 mm on Theia + }, + # http://robotsforroboticists.com/wordpress/wp-content/uploads/2019/09/realsense-sep-2019.pdf + {'name': 'realsense', + 'position_offset': {'x': -0.220317, 'y': 0.0325, 'z': 0.11}, + # rotation of the cameras around the Y axis (lateral car axis) in degrees + 'rotation': 0, + 'image_resolution': (1280, 960), + # used if camera_mask is set to True + 'segmentation_mask': 'realsense_segmentation_mask.png', + 'sensor_width': 6.4, # 1/2 inch, see above for source + 'sensor_height': 4.8, # 1/2 inch, see above for source + # 'focal_length': 1.93, -> documentation above incorrect, use horizontal FOV + 'horizontal_fov': 69.4 # unit: degrees + } + ] + } + + +if __name__ == "__main__": + os.makedirs(OUTPUT_DIR, exist_ok=True) + if os.listdir(OUTPUT_DIR) != [] and not FORCE_OUTPUT: + print("Output directory is not empty.") + print("Use --force") + sys.exit(1) + + shutil.copy2(INPUT_FILE, OUTPUT_DIR) + + with open(os.path.join(OUTPUT_DIR, 'config.json'), 'w', encoding='utf-8') as config_file: + json.dump(config, config_file, ensure_ascii=False, indent=4) + + with open(INPUT_FILE) as input_file: + xml = input_file.read() + + generate_blend(xml, OUTPUT_DIR, ADD_VEHICLE, OUTPUT_DIR, GAZEBO_WORLDS_PATH, GAZEBO_SIM_PATH, config) diff --git a/blender/__init__.py b/blender/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/blender/convert_segmentation_to_object_labels.py b/blender/convert_segmentation_to_object_labels.py new file mode 100644 index 0000000..f2b26c2 --- /dev/null +++ b/blender/convert_segmentation_to_object_labels.py @@ -0,0 +1,101 @@ +from glob import glob +from tqdm import tqdm +import os +import logging +import csv +import cv2 +import numpy as np +from blender.renderer.segmentation_colormap import SIGN_TO_COLOR, SIGN_TO_CLASSID +import argparse + + +_LOGGER = logging.getLogger(__name__) + + +def match_input_target_files(a, b): + # match base filenames only as formats differ between label files + a_mask = set(os.path.basename(fp).split('.')[0] for fp in a) + b_mask = set(os.path.basename(fp).split('.')[0] for fp in b) + + uncommon_mask = set.symmetric_difference(a_mask, b_mask) + if len(uncommon_mask) == 0: + _LOGGER.debug('No mismatch found between input and target files.') + return a, b + else: + _LOGGER.warning("Mismatching Image Ids found: {}".format(', '.join(s for s in uncommon_mask))) + return [fp for fp in a if "_".join(os.path.basename(fp).split('_')[0:3]) not in uncommon_mask], \ + [fp for fp in b if "_".join(os.path.basename(fp).split('_')[0:3]) not in uncommon_mask] + + +def convert_dataset_trafficsignid_only(base_path, draw_debug=False, min_pixel_size=50): + """ + Reads segmentation images and converts them to .csv file with annotations and visualizes it optionally + + Note: makes the assumption that two labels of the same type are not connected to each other, will treat them as + one label if that happens for some reason + """ + semseg_image_path = os.path.join(base_path, 'semseg_color') + instance_image_path = os.path.join(base_path, 'traffic_sign_id') + gt_path = os.path.join(base_path, 'signs_ground_truth.csv') + + segmentation_images = sorted(glob(os.path.join(semseg_image_path, '*.png'), recursive=False)) + instance_images = sorted(glob(os.path.join(instance_image_path, '*.exr'), recursive=False)) + + COLOR_TO_SIGN = {color: name for name, color in SIGN_TO_COLOR.items()} + + segmentation_images, instance_images = match_input_target_files(segmentation_images, instance_images) + + with open(gt_path, 'w') as csvfile: + gt_writer = csv.writer(csvfile, delimiter=',', quotechar='|', quoting=csv.QUOTE_MINIMAL) + gt_writer.writerow(['Filename', 'Roi.X1', 'Roi.X2', 'Roi.Y1', 'Roi.Y2', 'ClassId']) + for semantic_name, instance_name in tqdm(zip(segmentation_images, instance_images)): + semantic_image = cv2.imread(semantic_name) + instance_image = cv2.imread(instance_name)[..., 0] + + if draw_debug: + color_image = cv2.imread(os.path.join(base_path, 'rgb', + os.path.basename(semantic_name))) + + # find unique combinations of traffic sign id labels and cluster them, put bbs around and write + for traffic_sign_id in np.sort(np.unique(instance_image))[1:]: + location_mask = (instance_image == traffic_sign_id) + colors, counts = np.unique(semantic_image[location_mask], axis=0, return_counts=True) + dominant_color = colors[np.argsort(-counts)][0] + + if tuple(dominant_color)[::-1] in COLOR_TO_SIGN: + traffic_sign = SIGN_TO_CLASSID[COLOR_TO_SIGN[tuple(dominant_color)[::-1]]] + unique_positions = np.argwhere(location_mask) + + x1 = np.min(unique_positions[:, 0]) + x2 = np.max(unique_positions[:, 0]) + + y1 = np.min(unique_positions[:, 1]) + y2 = np.max(unique_positions[:, 1]) + + if (x2-x1) + (y2-y1) > min_pixel_size: + # we switch around the y and x coordinates here as this was done when hand-labeling + gt_writer.writerow([os.path.basename(semantic_name), y1, y2, x1, x2, traffic_sign]) + + if draw_debug: + cv2.rectangle(color_image, (y1, x1), (y2, x2), [int(val) for val in dominant_color]) + cv2.putText(color_image, str(traffic_sign), (y1, x1), cv2.FONT_HERSHEY_SIMPLEX, 0.5, + [int(val) for val in dominant_color]) + else: + logging.warning('Image: {}, Dominant color {} of sign with id: {} is not in the color' + ' dict, skipping!'.format(os.path.basename(semantic_name), dominant_color, traffic_sign_id)) + + if draw_debug: + cv2.destroyAllWindows() + cv2.imshow('Traffic signs in image {}'.format(os.path.basename(semantic_name)), color_image) + cv2.waitKey(0) + + +if __name__ == '__main__': + parser = argparse.ArgumentParser(description='Generate phoenix-style annotations from synthetic segmantation & ' + 'sign id') + parser.add_argument('path', type=str, nargs=1, + help='Filepath, should contain the \'semseg_color\' and \'traffic_sign_id\' sub-paths') + args = parser.parse_args() + + # change the pixel size accordingly to remove too small signs (unit is square pixels) + convert_dataset_trafficsignid_only(args.path[0], draw_debug=False, min_pixel_size=50) diff --git a/blender/renderer/__init__.py b/blender/renderer/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/blender/renderer/blender.py b/blender/renderer/blender.py new file mode 100644 index 0000000..2637748 --- /dev/null +++ b/blender/renderer/blender.py @@ -0,0 +1,265 @@ +from blender.renderer import groundplane, obstacle, traffic_sign, ego_vehicle, special_objects +# we assume that the road width config set here is the same used during the generation +from commonroad import schema +from os import path, makedirs +import bpy +import os +from commonroad.renderer.ego_vehicle import get_start_lanelet, get_next_lanelet, middle_of_lanelet, middle_of_lanelet_equidistant +import math +from tqdm import tqdm +from blender.renderer import env_configs +import random +import cv2 + + +def get_keyframes(lanelets, config): + current_lanelet = get_start_lanelet(lanelets) + t = 0 + last_point = None + keyframes = [] + while current_lanelet is not None: + middle = middle_of_lanelet_equidistant(current_lanelet, step_length=config['render_interval_distance']) + for p in middle: + if last_point is not None: + orientation = math.atan2(p[1] - last_point[1], p[0] - last_point[0]) + else: + orientation = 0 + keyframes.append({'t': t, 'x': p[0], 'y': p[1], 'z': 0, 'orientation': orientation}) + if last_point is not None: + dx = last_point[0] - p[0] + dy = last_point[1] - p[1] + t += math.sqrt(dx * dx + dy * dy) + last_point = p + current_lanelet = get_next_lanelet(lanelets, current_lanelet) + return keyframes + + +def setup_env(scene_rgb, scene_seg, scene_lanes, env_config): + scene_seg.render.engine = 'BLENDER_RENDER' + scene_lanes.render.engine = 'BLENDER_RENDER' + + scene_rgb.render.engine = 'CYCLES' + scene_rgb.cycles.device = 'GPU' + scene_rgb.cycles.samples = 350 + scene_rgb.cycles.preview_samples = 64 + scene_rgb.render.layers[0].cycles.use_denoising = True + world = bpy.data.worlds['World'] + world.use_nodes = True + nt = world.node_tree + bg_node = nt.nodes.new(type="ShaderNodeTexEnvironment") + bg_node.image = bpy.data.images.load(env_config['image_path']) + scene_rgb.world = world + + # find location of Background node and position Grad node to the left + backNode = nt.nodes['Background'] + bg_node.location.x = backNode.location.x - 300 + bg_node.location.y = backNode.location.y + + mapping_node = nt.nodes.new(type="ShaderNodeMapping") + mapping_node.rotation = env_config['rotation'] + mapping_node.scale = env_config['scale'] + mapping_node.translation = env_config['translation'] + nt.links.new(mapping_node.outputs['Vector'], bg_node.inputs['Vector']) + + coord_node = nt.nodes.new(type="ShaderNodeTexCoord") + nt.links.new(coord_node.outputs['Generated'], mapping_node.inputs['Vector']) + + gradColOut = bg_node.outputs['Color'] + backColIn = backNode.inputs['Color'] + nt.links.new(gradColOut, backColIn) + + # add instance id output + scene_seg.render.layers["RenderLayer"].use_pass_combined = False + scene_seg.render.layers["RenderLayer"].use_pass_z = False + scene_seg.render.layers["RenderLayer"].use_pass_diffuse = False + scene_seg.render.layers["RenderLayer"].use_pass_color = True + scene_seg.render.layers["RenderLayer"].use_pass_object_index = False + scene_seg.render.layers["RenderLayer"].use_pass_material_index = True + scene_seg.use_nodes = True + seg_tree = scene_seg.node_tree + instance_out_node = seg_tree.nodes.new(type="CompositorNodeOutputFile") + instance_out_node.name = 'InstanceOutput' + instance_out_node.format.compression = 0 + instance_out_node.file_slots[0].path = 'Image.exr' + instance_out_node.format.file_format = 'OPEN_EXR' + seg_tree.links.new(seg_tree.nodes['Render Layers'].outputs['Color'], seg_tree.nodes['Composite'].inputs['Image']) + seg_tree.links.new(seg_tree.nodes['Render Layers'].outputs['IndexMA'], instance_out_node.inputs['Image']) + + +def render_keyframes(lanelets, output_path, scene_rgb, scene_seg, scene_lanes, config, add_vehicle=True, + car_name='ego_vehicle'): + if config['use_vehicle_mask']: + vehicle_masks = [] + + for camera_config in config['cameras']: + bpy.ops.object.camera_add(view_align=True, location=(0, 0, 0), rotation=(0, 0, 0)) + cam_name = camera_config['name'] + bpy.data.cameras[bpy.context.active_object.name].name = cam_name + bpy.context.active_object.name = cam_name + bpy.data.cameras[cam_name].clip_start = 0.05 # to prevent clipping of vehicle body + bpy.data.cameras[cam_name].sensor_fit = 'HORIZONTAL' + bpy.data.cameras[cam_name].sensor_width = camera_config['sensor_width'] + bpy.data.cameras[cam_name].sensor_height = camera_config['sensor_height'] + if 'focal_length' in camera_config: + bpy.data.cameras[cam_name].lens = camera_config['focal_length'] + elif 'horizontal_fov' in camera_config: + bpy.data.cameras[cam_name].lens_unit = 'FOV' + bpy.data.objects[cam_name].data.angle_x = camera_config['horizontal_fov'] * math.pi/180 + else: + print('No lens config provided for camera \'{}\', using defaults'.format(cam_name)) + + camera_path = os.path.join(output_path, cam_name) + + if not os.path.isdir(os.path.join(camera_path, 'rgb')): + os.makedirs(os.path.join(camera_path, 'rgb')) + + if not os.path.isdir(os.path.join(camera_path, 'semseg_color')): + os.makedirs(os.path.join(camera_path, 'semseg_color')) + + if not os.path.isdir(os.path.join(camera_path, 'traffic_sign_id')): + os.makedirs(os.path.join(camera_path, 'traffic_sign_id')) + + if not os.path.isdir(os.path.join(camera_path, 'lane_segmentation')): + os.makedirs(os.path.join(camera_path, 'lane_segmentation')) + + if config['use_vehicle_mask']: + vehicle_masks.append(cv2.imread(os.path.join('blender', 'segmentation_masks', + camera_config['segmentation_mask']), + cv2.IMREAD_UNCHANGED)) + + keyframes = get_keyframes(lanelets, config) + + seg_tree = scene_seg.node_tree + seg_tree.nodes['Render Layers'].scene = scene_seg + + instance_out_node = seg_tree.nodes['InstanceOutput'] + seg_tree.links.new(seg_tree.nodes['Render Layers'].outputs['IndexMA'], instance_out_node.inputs['Image']) + + scene_rgb.render.use_file_extension = False + scene_seg.render.use_file_extension = False + scene_seg.display_settings.display_device = 'None' + scene_lanes.display_settings.display_device = 'None' + + bpy.context.user_preferences.addons['cycles'].preferences.compute_device_type = 'CUDA' + + for idx, keyframe in enumerate(tqdm(keyframes[config['frame_range'][0]: config['frame_range'][1]])): + name_idx = idx + config['frame_range'][0] + pos_x = keyframe['x'] + pos_y = keyframe['y'] + orientation = keyframe['orientation'] + if config['add_random_jitter']: + pos_x = keyframe['x'] + random.uniform(-config['random_jitter']['x'], config['random_jitter']['x']) + pos_y = keyframe['y'] + random.uniform(-config['random_jitter']['y'], config['random_jitter']['y']) + orientation = keyframe['orientation'] + random.uniform(-config['random_jitter']['angle'], + config['random_jitter']['angle']) * math.pi / 180 + + if add_vehicle: + car = bpy.data.objects[car_name] + car.location = (pos_x, + pos_y, + 0) + car.rotation_euler = [0, 0, orientation + math.pi] + + if not config['use_vehicle_mask']: + seg_car = bpy.data.objects['seg-' + car_name] + seg_car.location = (pos_x, + pos_y, + 0) + seg_car.rotation_euler = [0, 0, orientation + math.pi] + + for cam_idx, camera_config in enumerate(config['cameras']): + cam_name = camera_config['name'] + print('Rendering camera: {}'.format(cam_name)) + camera = bpy.data.objects[cam_name] + scene_rgb.camera = camera + scene_seg.camera = camera + scene_lanes.camera = camera + + camera_path = os.path.join(output_path, cam_name) + resolution = camera_config['image_resolution'] + scene_rgb.render.resolution_x = resolution[0] + scene_rgb.render.resolution_y = resolution[1] + scene_rgb.render.image_settings.compression = 0 + scene_rgb.render.resolution_percentage = 100 + + scene_seg.render.resolution_x = resolution[0] + scene_seg.render.resolution_y = resolution[1] + scene_seg.render.image_settings.compression = 0 + scene_seg.render.resolution_percentage = 100 + + scene_lanes.render.resolution_x = resolution[0] + scene_lanes.render.resolution_y = resolution[1] + scene_lanes.render.image_settings.compression = 0 + scene_lanes.render.resolution_percentage = 100 + + camera_offset = camera_config['position_offset'] + camera_orientation_y = camera_config['rotation'] * math.pi/180.0 + + bpy.context.screen.scene = scene_rgb + scene_rgb.render.layers["RenderLayer"].use_pass_combined = True + scene_rgb.render.layers["RenderLayer"].use_pass_z = True + scene_rgb.render.layers["RenderLayer"].use_pass_diffuse = False + + camera.location = (pos_x + camera_offset['x'] * math.cos(orientation) - camera_offset['y'] * math.sin(orientation), + pos_y + camera_offset['x'] * math.sin(orientation) + camera_offset['y'] * math.cos(orientation), + camera_offset['z']) + camera.rotation_euler = [-math.pi/2 - camera_orientation_y, math.pi, orientation + math.pi/2] + if 'rgb' in config['render_passes']: + scene_rgb.render.filepath = os.path.join(camera_path, 'rgb', 'Image{:04d}.png'.format(name_idx+1)) + bpy.ops.render.render(write_still=True) + + instance_out_node = seg_tree.nodes['InstanceOutput'] + instance_out_node.base_path = os.path.join(camera_path, 'traffic_sign_id') + + # activate diffuse pass only for scene + if 'semseg_color' in config['render_passes'] or 'instances' in config['render_passes']: + bpy.context.screen.scene = scene_seg + scene_seg.render.filepath = os.path.join(camera_path, 'semseg_color', 'Image{:04d}.png'.format( + name_idx+1)) + bpy.ops.render.render(write_still=True) + # blender seems to insist of plastering the frame number at the end of the file. fix manually + os.rename(os.path.join(camera_path, 'traffic_sign_id', 'Image.exr0001'), + os.path.join(camera_path, 'traffic_sign_id', 'Image{:04d}.exr'.format(name_idx+1))) + + # draw vehicle mask + if config['use_vehicle_mask']: + vehicle_mask = vehicle_masks[cam_idx] + rendered_image = cv2.imread(scene_seg.render.filepath) + rendered_image[vehicle_mask[..., -1] != 0] = vehicle_mask[vehicle_mask[..., -1] != 0][..., :-1] + cv2.imwrite(scene_seg.render.filepath, rendered_image) + + if 'lanes' in config['render_passes']: + bpy.context.screen.scene = scene_lanes + scene_lanes.render.filepath = os.path.join(camera_path, 'lane_segmentation', + 'Image{:04d}.png'.format(name_idx+1)) + bpy.ops.render.render(write_still=True) + + +def generate_blend(xml_content, target_dir, add_vehicle, output_dir, gazebo_world_path, gazebo_sim_path, config): + # delete box in scene originally + doc = schema.CreateFromDocument(xml_content) + + bpy.ops.object.delete(use_global=False) + scene_rgb = bpy.data.scenes.new("RGB") + scene_segmentation = bpy.data.scenes.new("Semantic Segmentation") + scene_lanes = bpy.data.scenes.new("Lane Segmentation") + + scenes = {'rgb': scene_rgb, 'segmentation': scene_segmentation, 'lane_detection': scene_lanes} + + groundplane.draw(doc, target_dir, scenes, obstacle, config) + if add_vehicle: + # render keyframes at the end by moving the object and calling bpy + ego_vehicle.draw(gazebo_sim_path, scene_rgb, scene_segmentation, config) + for obst in doc.obstacle: + if obst.type != "blockedArea" and obst.type != "segmentationIntersection": + obstacle.draw(obst, scene_rgb, scene_segmentation) + mesh_basepath = os.path.join(gazebo_world_path, 'meshes') + for sign_idx, sign in enumerate(doc.trafficSign): + traffic_sign.draw(sign, mesh_basepath, scene_rgb, scene_segmentation, sign_idx=sign_idx+1) + for ramp in doc.ramp: + special_objects.draw_ramp(ramp, mesh_basepath, scene_rgb, scene_segmentation) + + setup_env(scene_rgb, scene_segmentation, scene_lanes, getattr(env_configs, config['env_config'])) + render_keyframes(doc.lanelet, output_dir, scene_rgb, scene_segmentation, scene_lanes, + config, add_vehicle=add_vehicle) + # bpy.ops.wm.save_mainfile(os.path.join(output_dir, 'render_scene.blend'), compress=False) diff --git a/blender/renderer/ego_vehicle.py b/blender/renderer/ego_vehicle.py new file mode 100644 index 0000000..48d5a21 --- /dev/null +++ b/blender/renderer/ego_vehicle.py @@ -0,0 +1,24 @@ +import bpy +import os +import math +from blender.renderer.segmentation_colormap import EGO_VEHICLE_COLOR +from blender.renderer.utils import duplicate_add_segmentation + + +def draw(gazebo_sim_path, scene_rgb, scene_seg, config): + model_file = 'high_shell_export.dae' + model_path = os.path.join(gazebo_sim_path, 'meshes', model_file) + bpy.ops.wm.collada_import(filepath=model_path) + + ego_vehicle_name = 'ego_vehicle' + bpy.context.active_object.name = ego_vehicle_name + ego_vehicle = bpy.data.objects[ego_vehicle_name] + ego_vehicle.data.use_auto_smooth = True + bpy.context.scene.cursor_location = (0, 0, 0) + bpy.ops.object.origin_set(type='ORIGIN_CURSOR') + ego_vehicle.rotation_euler = (0, 0, math.pi) + scene_rgb.objects.link(ego_vehicle) + + if not config['use_vehicle_mask']: + duplicate_add_segmentation('seg-' + ego_vehicle_name, EGO_VEHICLE_COLOR, scene_seg) + return ego_vehicle_name diff --git a/blender/renderer/env_configs.py b/blender/renderer/env_configs.py new file mode 100644 index 0000000..ce83fb7 --- /dev/null +++ b/blender/renderer/env_configs.py @@ -0,0 +1,59 @@ +import math + +# image can be downloaded here: https://hdrihaven.com/hdri/?h=colorful_studio +colorful_studio_back = { + 'image_path': '/home/mykyta/phoenix/colorful_studio_4k.hdr', + 'rotation': (0.0, 0.0, 70/180.0 * math.pi), # degrees + 'scale': (0.001, 0.001, 0.001), + 'translation': (0.0, 0.0, 0.0) +} + +# image can be downloaded here https://hdrihaven.com/hdri/?c=studio&h=studio_small_05 +studio_small_05 = { + 'image_path': '/home/mykyta/phoenix/studio_small_05_4k.hdr', + 'rotation': (0.0, 0.0, 50/180.0 * math.pi), # degrees + 'scale': (0.0001, 0.0001, 0.0001), + 'translation': (0.0, 0.0, -0.00001) +} + +# image can be downloaded here https://hdrihaven.com/hdri/?c=indoor&h=subway_entrance +subway_entrance = { + 'image_path': '/home/mykyta/phoenix/subway_entrance_4k.hdr', + 'rotation': (0.0, 0.0, 70/180.0 * math.pi), # degrees + 'scale': (0.0001, 0.0001, 0.0001), + 'translation': (0.0, 0.0, -0.00001) +} + +# image can be downloaded here https://hdrihaven.com/hdri/?c=indoor&h=wooden_lounge +wooden_lounge = { + 'image_path': '/home/mykyta/phoenix/wooden_lounge_4k.hdr', + 'rotation': (0.0, 0.0, 0.0), # degrees + 'scale': (0.0001, 0.0001, 0.0001), + 'translation': (0.0, 0.0, -0.00001) +} + +# image can be downloaded here https://hdrihaven.com/files/hdris/machine_shop_03_4k.hdr +machine_shop = { + 'image_path': '/home/mykyta/phoenix/machine_shop_03_4k.hdr', + 'rotation': (0.0, 0.0, 0.0), # degrees + 'scale': (0.0001, 0.0001, 0.0001), + 'translation': (0.0, 0.0, -0.00001) +} + +# image can be downloaded here: https://hdrihaven.com/hdri/?c=indoor&h=industrial_pipe_and_valve_01 +industrial_pipe = { + 'image_path': '/home/mykyta/phoenix/industrial_pipe_and_valve_01_4k.hdr', + 'rotation': (0.0, 0.0, 30/180.0 * math.pi), # degrees + 'scale': (0.001, 0.001, 0.001), + 'translation': (0.0, 0.0, 0.0) +} + +# image can be downloaded here: https://hdrihaven.com/hdri/?c=indoor&h=autoshop_01 +autoshop = { + 'image_path': '/home/ubuntu/Downloads/autoshop_01_4k.hdr', + 'rotation': (0.0, 0.0, 10/180.0 * math.pi), # degrees + 'scale': (0.001, 0.001, 0.001), + 'translation': (0.0, 0.0, 0.0) +} + + diff --git a/blender/renderer/groundplane.py b/blender/renderer/groundplane.py new file mode 100644 index 0000000..2face2a --- /dev/null +++ b/blender/renderer/groundplane.py @@ -0,0 +1,485 @@ +import cairo +# have to use pycairo instead of cairocffi as Rsvg bindings don't work with the latter +#import cairocffi as cairo +import math +from commonroad import utils +from os import path +import os +import hashlib +from tqdm import tqdm +import numpy as np +from enum import Enum +from collections import namedtuple +import gi +gi.require_version('Rsvg', '2.0') +from gi.repository import Rsvg +from commonroad.renderer.groundplane import draw_stop_line +from commonroad.renderer.groundplane import draw_zebra_crossing +from commonroad.renderer.groundplane import draw_all_boundaries +from commonroad.renderer.groundplane import draw_obstacle +from commonroad.renderer.groundplane import draw_island_junction +from commonroad.renderer.groundplane import draw_road_marking +from commonroad.renderer.groundplane import ROADMARKING_TYPE_TO_VISUAL +from commonroad.renderer.groundplane import boundary_to_equi_distant +from commonroad.renderer.groundplane import expand_boundary +from commonroad.renderer.groundplane import get_lanelet_by_id +from commonroad.renderer.groundplane import draw_rectangle +from PIL import Image, ImageOps + + +from blender.renderer.utils import generate_material_cycles, generate_material_internal_segmentation + +import bpy +import bmesh +from mathutils import Vector +from blender.renderer.segmentation_colormap import BACKGROUND_COLOR, DRIVABLE_AREA_SEGMENTATION_COLOR,\ + LANE_MARKING_SEGMENTATION_COLOR, STOPLINE_DASHED_SEGMENTATION_COLOR, STOPLINE_SEGMENTATION_COLOR, \ + ZEBRA_COLOR, BLOCKED_AREA_SEGMENTATION_COLOR, TRAFFIC_MARKING_SEGMENTATION_COLORS, INTERSECTION_COLOR, \ + LANE_MARKING_RIGHT_SIDE, LANE_MARKING_MIDDLE, LANE_MARKING_LEFT_SIDE +from blender.renderer.segmentation_colormap import convert_to_one_range + + +PIXEL_PER_UNIT = 500 +TILE_SIZE = 2048 +PADDING = 3 + + +def add_ground_segment(texture_file, x, y, segment_scale, segment_name, scene, config, segmap=False): + bpy.data.images.load(texture_file) + + bpy.ops.mesh.primitive_plane_add(location=(x, y, 0)) + bpy.context.active_object.name = segment_name + obj = bpy.data.objects[segment_name] + obj.scale[0] = segment_scale/2 + obj.scale[1] = segment_scale/2 + obj.select = True + + lm = obj.data.uv_textures.get("UV") + if not lm: + lm = obj.data.uv_textures.new("UV") + lm.active = True + bpy.ops.object.editmode_toggle() + bpy.ops.uv.unwrap() + + # scale down uv map to prevent bleed -> not necessary if texture is not mirrored + # me = obj.data + # bm = bmesh.from_edit_mesh(me) + # uv_layer = bm.loops.layers.uv.verify() + # bm.faces.layers.tex.verify() # currently blender needs both layers. + # for f in bm.faces: + # for l in f.loops: + # l[uv_layer].uv *= scale_factor + # l[uv_layer].uv += Vector(((1 - scale_factor)/2, (1 - scale_factor)/2)) + # bmesh.update_edit_mesh(me) + # + bpy.ops.object.editmode_toggle() + + if segmap: + mat = generate_material_internal_segmentation(segment_name, texture_file) + mat.texture_slots[0].texture_coords = 'UV' + mat.texture_slots[0].texture.use_mipmap = False + else: + bpy.context.scene.objects.active = obj + bpy.ops.mesh.uv_texture_add() + mat = generate_material_cycles(segment_name, texture_file, shader_type=config['groundplane_shader_type']) + + obj.data.materials.append(mat) + + scene.objects.link(obj) + + +def draw_stop_lines_segmentation(ctx, lanelet): + ctx.save() + p1 = lanelet.leftBoundary.point[-1] + p2 = lanelet.rightBoundary.point[-1] + + if lanelet.stopLine: + ctx.set_source_rgb(*convert_to_one_range(STOPLINE_SEGMENTATION_COLOR)) + lineWidth = 0.04 + segmentLength = 0.08 + segmentGap = 0.06 + if lanelet.stopLine == "dashed": + ctx.set_source_rgb(*convert_to_one_range(STOPLINE_DASHED_SEGMENTATION_COLOR)) + else: + ctx.set_dash([]) + ctx.set_line_cap(cairo.LINE_CAP_BUTT) + ctx.set_line_width(lineWidth) + ctx.move_to(p1.x, p1.y) + ctx.line_to(p2.x, p2.y) + ctx.stroke() + ctx.restore() + + +def draw_zebra_crossing_segmentation(ctx, lanelet): + ctx.save() + ctx.set_source_rgb(*convert_to_one_range(ZEBRA_COLOR)) + ctx.move_to(lanelet.leftBoundary.point[0].x, lanelet.leftBoundary.point[0].y) + ctx.line_to(lanelet.leftBoundary.point[1].x, lanelet.leftBoundary.point[1].y) + ctx.line_to(lanelet.rightBoundary.point[1].x, lanelet.rightBoundary.point[1].y) + ctx.line_to(lanelet.rightBoundary.point[0].x, lanelet.rightBoundary.point[0].y) + ctx.close_path() + ctx.fill() + ctx.stroke() + ctx.restore() + + +# a separate function that tracks the lane segments following each other and gets an index of the first one would +# be needed to do full drivable / adjacent segmentation (no ego-lane information here) +def draw_drivable_segmentation(ctx, lanelet_list): + all_ids = [lanelet.id for lanelet in lanelet_list] + while len(all_ids) > 0: + current_id = all_ids[0] + suc = expand_boundary(lanelet_list, get_lanelet_by_id(lanelet_list, current_id), 'rightBoundary', "successor", + ignore_boundary=True) + pred = expand_boundary(lanelet_list, get_lanelet_by_id(lanelet_list, current_id), 'rightBoundary', + "predecessor", ignore_boundary=True) + ids_in_run = pred[::-1] + [current_id] + suc + + for id in ids_in_run: + all_ids.remove(id) + + lanelets = list(map(lambda x: get_lanelet_by_id(lanelet_list, x), ids_in_run)) + + ctx.save() + ctx.set_source_rgb(*convert_to_one_range(DRIVABLE_AREA_SEGMENTATION_COLOR)) + + ctx.move_to(lanelets[0].rightBoundary.point[0].x, + lanelets[0].rightBoundary.point[0].y) + + for lanelet in lanelets: + for p in lanelet.rightBoundary.point: + ctx.line_to(p.x, p.y) + + for lanelet in reversed(lanelets): + for p in reversed(lanelet.leftBoundary.point): + ctx.line_to(p.x, p.y) + ctx.fill() + ctx.stroke() + ctx.restore() + + +# necessary because otherwise we have bleeding artifacts between the two road lanes +def draw_midline_gap_segmentation(ctx, lanelet_list, boundary_name): + all_ids = [lanelet.id for lanelet in lanelet_list + if getattr(lanelet, boundary_name).lineMarking is not None] + while len(all_ids) > 0: + current_id = all_ids[0] + suc = expand_boundary(lanelet_list, get_lanelet_by_id(lanelet_list, current_id), boundary_name, "successor") + pred = expand_boundary(lanelet_list, get_lanelet_by_id(lanelet_list, current_id), boundary_name, "predecessor") + ids_in_run = pred[::-1] + [current_id] + suc + + for id in ids_in_run: + all_ids.remove(id) + + lanelets = list(map(lambda x: get_lanelet_by_id(lanelet_list, x), ids_in_run)) + + ctx.save() + ctx.set_source_rgb(*convert_to_one_range(DRIVABLE_AREA_SEGMENTATION_COLOR)) + ctx.set_line_width (0.02) + + ctx.move_to(getattr(lanelets[0], boundary_name).point[0].x, + getattr(lanelets[0], boundary_name).point[0].y) + + for lanelet in lanelets: + for p in getattr(lanelet, boundary_name).point: + ctx.line_to(p.x, p.y) + ctx.stroke() + ctx.restore() + + +def draw_drivable_boundaries(ctx, lanelet_list, boundary_name, color=(1, 1, 1), starting_idx=0): + ctx.set_source_rgb(*color) + all_ids = [lanelet.id for lanelet in lanelet_list + if getattr(lanelet, boundary_name).lineMarking is not None] + + # follows the lanes connected to 0 lane only (the starting lane segment) + if starting_idx == 0: + current_id = all_ids[starting_idx] + else: + current_id = starting_idx + suc = expand_boundary(lanelet_list, get_lanelet_by_id(lanelet_list, current_id), boundary_name, "successor", + ignore_boundary=True) + pred = expand_boundary(lanelet_list, get_lanelet_by_id(lanelet_list, current_id), boundary_name, "predecessor", + ignore_boundary=True) + ids_in_run = pred[::-1] + [current_id] + suc + + lanelets = list(map(lambda x: get_lanelet_by_id(lanelet_list, x), ids_in_run)) + + ctx.save() + ctx.set_line_width (0.02) + + ctx.move_to(getattr(lanelets[0], boundary_name).point[0].x, + getattr(lanelets[0], boundary_name).point[0].y) + + for lanelet in lanelets: + for p in getattr(lanelet, boundary_name).point: + ctx.line_to(p.x, p.y) + ctx.stroke() + ctx.restore() + + +def draw_blocked_area_segmentation(ctx, rectangle): + ctx.save() + ctx.set_source_rgb(*convert_to_one_range(BLOCKED_AREA_SEGMENTATION_COLOR)) + ctx.translate(rectangle.centerPoint.x, rectangle.centerPoint.y) + ctx.rotate(-rectangle.orientation) + + ctx.set_line_width (0.02) + sheering = rectangle.width / 2 + ctx.move_to(- rectangle.length / 2, - rectangle.width / 2) + ctx.line_to(rectangle.length / 2, - rectangle.width / 2) + ctx.line_to(rectangle.length / 2 - sheering, rectangle.width / 2) + ctx.line_to(- rectangle.length / 2 + sheering, rectangle.width / 2) + ctx.close_path() + ctx.fill() + ctx.stroke() + ctx.restore() + + +def draw_obstacle_segmentation(ctx, obstacle): + if obstacle.type == "blockedArea": + for rect in obstacle.shape.rectangle: + draw_blocked_area_segmentation(ctx, rect) + elif obstacle.type == "segmentationIntersection": + for rect in obstacle.shape.rectangle: + draw_rectangle(ctx, rect, color=INTERSECTION_COLOR) + + +def draw_road_marking_segmentation(ctx, marking): + ctx.set_source_rgb(*convert_to_one_range(TRAFFIC_MARKING_SEGMENTATION_COLORS[marking.type])) + marking_visual = ROADMARKING_TYPE_TO_VISUAL[marking.type] + if marking_visual.marker_text: + ctx.save() + ctx.set_dash([]) + font = "DIN 1451 Std" + font_size = 0.4 + text = '30' + font_args = [cairo.FONT_SLANT_NORMAL] + ctx.translate(marking.centerPoint.x, # - 0.145*math.cos(marking.orientation), + marking.centerPoint.y) # - 0.145*math.sin(marking.orientation)) + ctx.rotate(marking.orientation) + # mirror text + ctx.transform(cairo.Matrix(1.0, 0, 0, -1, 0, 0)) + ctx.translate(-0.145, 0.29) + ctx.select_font_face(font, *font_args) + ctx.set_font_size(font_size) + ctx.text_path(marking_visual.marker_text) + ctx.set_line_width(0.01) + (x_bearing, y_bearing, text_width, text_height, + x_advance, y_advance) = ctx.text_extents(text) + ctx.fill_preserve() + ctx.stroke() + ctx.restore() + if marking_visual.crossed: + ctx.save() + ctx.move_to(marking.centerPoint.x + 0.145 * math.cos(marking.orientation), + marking.centerPoint.y + 0.145 * math.sin(marking.orientation)) + ctx.line_to(marking.centerPoint.x + 0.145 * math.cos(marking.orientation) + - text_height * math.cos(marking.orientation) + text_width * math.sin(marking.orientation), + marking.centerPoint.y + 0.145 * math.sin(marking.orientation) + - text_height * math.sin(marking.orientation) - text_width * math.cos(marking.orientation)) + ctx.move_to(marking.centerPoint.x + (0.145 - text_height) * math.cos(marking.orientation), + marking.centerPoint.y + (0.145 - text_height) * math.sin(marking.orientation)) + ctx.line_to(marking.centerPoint.x + 0.145 * math.cos(marking.orientation) + + text_width * math.sin(marking.orientation), + marking.centerPoint.y + 0.145 * math.sin(marking.orientation) + - text_width * math.cos(marking.orientation)) + ctx.set_line_width(0.05) + ctx.stroke() + ctx.restore() + + if marking_visual.marker_image: + # draw to temporary surface first to be able to change color + ctx.save() + img = cairo.ImageSurface(cairo.FORMAT_ARGB32, 72, 500) # todo: will have to change size dynamically if we add other markers in the future, for now all have this size + ctx_temp = cairo.Context(img) + handle = Rsvg.Handle() + svg = handle.new_from_file(marking_visual.marker_image.value) + svg.render_cairo(ctx_temp) + + ctx.translate(marking.centerPoint.x, marking.centerPoint.y) + ctx.rotate(marking.orientation) + ctx.scale(0.001, 0.001) + # ctx.scale(-1, 1) + # ctx.translate(-72, 0) # todo: will have to change size dynamically if we add other markers in the future, for now all have this size + ctx.mask_surface(img) + ctx.stroke() + ctx.restore() + + +def pad_png(path, ratio): + im = Image.open(path) + old_size = im.size # old_size[0] is in (width, height) format + + new_size = tuple([int(x * ratio) + 3 for x in old_size]) + + im = im.resize(new_size, Image.ANTIALIAS) + new_im = Image.new("RGB", old_size) + new_im.paste(im, ((old_size[0] - new_size[0]) // 2, (old_size[1] - new_size[1]) // 2)) + new_im.save(path) + + +def draw(doc, target_dir, scenes, obstacles, config): + bounding_box = utils.get_bounding_box(doc) + bounding_box.x_min -= PADDING + bounding_box.y_min -= PADDING + bounding_box.x_max += PADDING + bounding_box.y_max += PADDING + + width = math.ceil((bounding_box.x_max - bounding_box.x_min) * PIXEL_PER_UNIT) + height = math.ceil((bounding_box.y_max - bounding_box.y_min) * PIXEL_PER_UNIT) + + width_num = int(math.ceil(width / TILE_SIZE)) + height_num = int(math.ceil(height / TILE_SIZE)) + + os.makedirs(path.join(target_dir, "materials", "textures"), exist_ok=True) + + for (x, y) in tqdm([(x,y) for x in range(width_num) for y in range(height_num)]): + surface = cairo.ImageSurface(cairo.FORMAT_RGB24, TILE_SIZE, TILE_SIZE) + ctx = cairo.Context(surface) + + # fill black + ctx.set_source_rgb(0, 0, 0) + ctx.rectangle(0, 0, TILE_SIZE, TILE_SIZE) + ctx.fill() + + # Inverse y-axis + ctx.translate(0, TILE_SIZE / 2) + ctx.scale(1, -1) + ctx.translate(0, -TILE_SIZE / 2) + + ctx.scale(PIXEL_PER_UNIT, PIXEL_PER_UNIT) + ctx.translate(-bounding_box.x_min, -bounding_box.y_min) + ctx.translate(- x * TILE_SIZE / PIXEL_PER_UNIT, - y * TILE_SIZE / PIXEL_PER_UNIT) + + ctx.set_source_rgb(1, 1, 1) + for lanelet in doc.lanelet: + draw_stop_line(ctx, lanelet) + if lanelet.type == "zebraCrossing": + draw_zebra_crossing(ctx, lanelet) + + draw_all_boundaries(ctx, doc.lanelet, "leftBoundary") + draw_all_boundaries(ctx, doc.lanelet, "rightBoundary") + + for obstacle in doc.obstacle: + draw_obstacle(ctx, obstacle) + + for island_junction in doc.islandJunction: + draw_island_junction(ctx, island_junction) + + for road_marking in doc.roadMarking: + draw_road_marking(ctx, road_marking) + + texture_file = "tile-{}-{}.png".format(x, y) + texture_path = path.join(target_dir, "materials", "textures", texture_file) + surface.write_to_png(texture_path) + + add_ground_segment( + texture_path, + bounding_box.x_min + (x + 0.5) * TILE_SIZE / PIXEL_PER_UNIT, + bounding_box.y_min + (y + 0.5) * TILE_SIZE / PIXEL_PER_UNIT, + TILE_SIZE / PIXEL_PER_UNIT, + "Tile_{0}_{1}".format(x, y), + scenes['rgb'], + config + ) + + # draw segmentation map + surface = cairo.ImageSurface(cairo.FORMAT_RGB24, TILE_SIZE, TILE_SIZE) + ctx = cairo.Context(surface) + + ctx.set_source_rgb(*BACKGROUND_COLOR) + ctx.rectangle(0, 0, TILE_SIZE, TILE_SIZE) + ctx.fill() + + # Inverse y-axis + ctx.translate(0, TILE_SIZE / 2) + ctx.scale(1, -1) + ctx.translate(0, -TILE_SIZE / 2) + + ctx.scale(PIXEL_PER_UNIT, PIXEL_PER_UNIT) + ctx.translate(-bounding_box.x_min, -bounding_box.y_min) + ctx.translate(- x * TILE_SIZE / PIXEL_PER_UNIT, - y * TILE_SIZE / PIXEL_PER_UNIT) + + draw_drivable_segmentation(ctx, doc.lanelet) + draw_midline_gap_segmentation(ctx, doc.lanelet, "leftBoundary") + for obstacle in doc.obstacle: + if obstacle.type == "segmentationIntersection": + for rect in obstacle.shape.rectangle: + draw_rectangle(ctx, rect, color=convert_to_one_range(INTERSECTION_COLOR)) + for lanelet in doc.lanelet: + draw_stop_lines_segmentation(ctx, lanelet) + if lanelet.type == "zebraCrossing": + draw_zebra_crossing_segmentation(ctx, lanelet) + + draw_all_boundaries(ctx, doc.lanelet, "leftBoundary", + convert_to_one_range(LANE_MARKING_SEGMENTATION_COLOR)) + draw_all_boundaries(ctx, doc.lanelet, "rightBoundary", + convert_to_one_range(LANE_MARKING_SEGMENTATION_COLOR)) + + for obstacle in doc.obstacle: + if obstacle.type == "blockedArea": + for rect in obstacle.shape.rectangle: + draw_blocked_area_segmentation(ctx, rect) + + # do not segment island junctions for now + # for island_junction in doc.islandJunction: + # draw_island_junction_segmentation(ctx, island_junction) + + for road_marking in doc.roadMarking: + draw_road_marking_segmentation(ctx, road_marking) + + texture_file = "segmentation-tile-{}-{}.png".format(x, y) + texture_path = path.join(target_dir, "materials", "textures", texture_file) + surface.write_to_png(texture_path) + + add_ground_segment( + texture_path, + bounding_box.x_min + (x + 0.5) * TILE_SIZE / PIXEL_PER_UNIT, + bounding_box.y_min + (y + 0.5) * TILE_SIZE / PIXEL_PER_UNIT, + TILE_SIZE / PIXEL_PER_UNIT, + "Seg-Tile_{0}_{1}".format(x, y), + scenes['segmentation'], + config, + segmap=True + ) + + # draw lane segmentation + surface = cairo.ImageSurface(cairo.FORMAT_RGB24, TILE_SIZE, TILE_SIZE) + ctx = cairo.Context(surface) + + ctx.set_source_rgb(*BACKGROUND_COLOR) + ctx.rectangle(0, 0, TILE_SIZE, TILE_SIZE) + ctx.fill() + + # Inverse y-axis + ctx.translate(0, TILE_SIZE / 2) + ctx.scale(1, -1) + ctx.translate(0, -TILE_SIZE / 2) + + ctx.scale(PIXEL_PER_UNIT, PIXEL_PER_UNIT) + ctx.translate(-bounding_box.x_min, -bounding_box.y_min) + ctx.translate(- x * TILE_SIZE / PIXEL_PER_UNIT, - y * TILE_SIZE / PIXEL_PER_UNIT) + + draw_drivable_boundaries(ctx, doc.lanelet, "leftBoundary", + convert_to_one_range(LANE_MARKING_MIDDLE)) + draw_drivable_boundaries(ctx, doc.lanelet, "rightBoundary", + convert_to_one_range(LANE_MARKING_RIGHT_SIDE)) + # left neightbor + draw_drivable_boundaries(ctx, doc.lanelet, "rightBoundary", convert_to_one_range(LANE_MARKING_LEFT_SIDE), + starting_idx=doc.lanelet[0].adjacentLeft.ref) + + texture_file = "lane_detection-tile-{}-{}.png".format(x, y) + texture_path = path.join(target_dir, "materials", "textures", texture_file) + surface.write_to_png(texture_path) + + add_ground_segment( + texture_path, + bounding_box.x_min + (x + 0.5) * TILE_SIZE / PIXEL_PER_UNIT, + bounding_box.y_min + (y + 0.5) * TILE_SIZE / PIXEL_PER_UNIT, + TILE_SIZE / PIXEL_PER_UNIT, + "Lane-Tile_{0}_{1}".format(x, y), + scenes['lane_detection'], + config, + segmap=True + ) \ No newline at end of file diff --git a/blender/renderer/obstacle.py b/blender/renderer/obstacle.py new file mode 100644 index 0000000..26e0d57 --- /dev/null +++ b/blender/renderer/obstacle.py @@ -0,0 +1,28 @@ +import bpy +from blender.renderer.segmentation_colormap import OBSTACLE_COLOR +from blender.renderer.utils import add_segmentation_mat + + +def obstacle_model(name, center_x, center_y, length, width, height, orientation, scene, color=None): + bpy.ops.mesh.primitive_cube_add() + bpy.context.active_object.name = name + obj = bpy.data.objects[name] + obj.location = (center_x, center_y, height/4) + obj.scale[0] = length/2 + obj.scale[1] = width/2 + obj.scale[2] = height/2 + obj.rotation_euler = [0, 0, orientation] + if color: + add_segmentation_mat(color, "Seg-Mat/Obstacle_{}".format(name), obj) + scene.objects.link(obj) + + +def draw(obst, scene_rgb, scene_segmentation): + for idx, rect in enumerate(obst.shape.rectangle): + obstacle_model("Obstacle/{0}/{1}".format(obst.id, idx), + rect.centerPoint.x, rect.centerPoint.y, rect.length, + rect.width, 0.2, - rect.orientation, scene_rgb) + + obstacle_model("Seg-Obstacle/{0}/{1}".format(obst.id, idx), + rect.centerPoint.x, rect.centerPoint.y, rect.length, + rect.width, 0.2, - rect.orientation, scene_segmentation, color=OBSTACLE_COLOR) \ No newline at end of file diff --git a/blender/renderer/segmentation_colormap.py b/blender/renderer/segmentation_colormap.py new file mode 100644 index 0000000..b3ce2ce --- /dev/null +++ b/blender/renderer/segmentation_colormap.py @@ -0,0 +1,134 @@ +from commonroad.renderer.groundplane import ROADMARKING_TYPE_TO_VISUAL +from commonroad.renderer.traffic_sign import SIGN_MESHES + +LANE_MARKING_SEGMENTATION_COLOR = (128, 0, 0) +BLOCKED_AREA_SEGMENTATION_COLOR = (0, 128, 0) +# pedestrian island currently not segmented, could do in the future +# PEDESTRIAN_ISLAND_COLOR = (0, 0, 128) +DRIVABLE_AREA_SEGMENTATION_COLOR = (0, 255, 0) +STOPLINE_SEGMENTATION_COLOR = (0, 255, 255) +STOPLINE_DASHED_SEGMENTATION_COLOR = (255, 255, 0) +ZEBRA_COLOR = (128, 128, 0) + +BACKGROUND_COLOR = (0, 0, 0) + +EGO_VEHICLE_COLOR = (100, 100, 100) + +OBSTACLE_COLOR = (0, 0, 255) + +RAMP_COLOR = (0, 100, 0) + +# Traffic markings on the road +# generated by : +# TRAFFIC_MARKING_SEGMENTATION_COLORS = {marking: (255 - 8 * i, 8 * i, 8 * i) for i, marking in +# enumerate(ROADMARKING_TYPE_TO_VISUAL.keys())} +TRAFFIC_MARKING_SEGMENTATION_COLORS = \ + {'10_zone_beginn': (255, 0, 0), + '20_zone_beginn': (247, 8, 8), + 'stvo-274.1': (239, 16, 16), + '40_zone_beginn': (231, 24, 24), + '50_zone_beginn': (223, 32, 32), + '60_zone_beginn': (215, 40, 40), + '70_zone_beginn': (207, 48, 48), + '80_zone_beginn': (199, 56, 56), + '90_zone_beginn': (191, 64, 64), + 'ende_10_zone': (183, 72, 72), + 'ende_20_zone': (175, 80, 80), + 'stvo-274.2': (167, 88, 88), + 'ende_40_zone': (159, 96, 96), + 'ende_50_zone': (151, 104, 104), + 'ende_60_zone': (143, 112, 112), + 'ende_70_zone': (135, 120, 120), + 'ende_80_zone': (127, 128, 128), + 'ende_90_zone': (119, 136, 136), + 'turn_left': (111, 144, 144), + 'turn_right': (103, 152, 152)} + +SIGN_BASE_COLOR = (200, 100, 0) + + +# Traffjcs signs +# generated by +# SIGN_TO_COLOR = {marking: (7 * i, 255 - 7 * i, 7 * i) for i, marking in +# enumerate(SIGN_MESHES.keys())} +SIGN_TO_COLOR = { + '10_zone_beginn': (0, 255, 0), + '20_zone_beginn': (7, 248, 7), + '40_zone_beginn': (14, 241, 14), + '50_zone_beginn': (21, 234, 21), + '60_zone_beginn': (28, 227, 28), + '70_zone_beginn': (35, 220, 35), + '80_zone_beginn': (42, 213, 42), + '90_zone_beginn': (49, 206, 49), + 'ende_10_zone': (56, 199, 56), + 'ende_20_zone': (63, 192, 63), + 'ende_40_zone': (70, 185, 70), + 'ende_50_zone': (77, 178, 77), + 'ende_60_zone': (84, 171, 84), + 'ende_70_zone': (91, 164, 91), + 'ende_80_zone': (98, 157, 98), + 'ende_90_zone': (105, 150, 105), + 'stvo-108-10': (112, 143, 112), + 'stvo-110-10': (119, 136, 119), + 'stvo-205': (126, 129, 126), + 'stvo-206': (133, 122, 133), + 'stvo-208': (140, 115, 140), + 'stvo-209-10': (147, 108, 147), + 'stvo-209-20': (154, 101, 154), + 'stvo-222': (161, 94, 161), + 'stvo-274.1': (168, 87, 168), + 'stvo-274.2': (175, 80, 175), + 'stvo-306': (182, 73, 182), + 'stvo-350-10': (189, 66, 189), + 'stvo-625-10': (196, 59, 196), + 'stvo-625-11': (203, 52, 203), + 'stvo-625-20': (210, 45, 210), + 'stvo-625-21': (217, 38, 217)} + + +SIGN_TO_CLASSID = { + '10_zone_beginn': 112, + '20_zone_beginn': 0, + '40_zone_beginn': 113, + '50_zone_beginn': 2, + '60_zone_beginn': 3, + '70_zone_beginn': 4, + '80_zone_beginn': 5, + '90_zone_beginn': 114, + 'ende_10_zone': 101, + 'ende_20_zone': 101, + 'ende_40_zone': 101, + 'ende_50_zone': 101, + 'ende_60_zone': 101, + 'ende_70_zone': 101, + 'ende_80_zone': 101, + 'ende_90_zone': 101, + 'stvo-108-10': 107, + 'stvo-110-10': 108, # actually should be 110 + 'stvo-205': 13, + 'stvo-206': 14, + 'stvo-208': 100, + 'stvo-209-10': 34, + 'stvo-209-20': 33, + 'stvo-222': 38, + 'stvo-274.1': 1, + 'stvo-274.2': 101, + 'stvo-306': 12, + 'stvo-350-10': 102, + 'stvo-625-10': 103, + 'stvo-625-11': 104, + 'stvo-625-20': 105, + 'stvo-625-21': 106} + +INTERSECTION_COLOR = (64, 128, 255) + +# only used in separate lane segmentation map +LANE_MARKING_RIGHT_SIDE = (51, 51, 51) +LANE_MARKING_MIDDLE = (151, 151, 151) +LANE_MARKING_LEFT_SIDE = (251, 251, 251) + + +def convert_to_one_range(color): + return (color[0]/255, color[1]/255, color[2]/255) + + diff --git a/blender/renderer/special_objects.py b/blender/renderer/special_objects.py new file mode 100644 index 0000000..e23ef3c --- /dev/null +++ b/blender/renderer/special_objects.py @@ -0,0 +1,21 @@ +import bpy +import os +from blender.renderer.segmentation_colormap import RAMP_COLOR +from blender.renderer.utils import duplicate_add_segmentation + + +def draw_ramp(ramp, mesh_path, scene_rgb, scene_seg): + bpy.ops.wm.collada_import(filepath=os.path.join(mesh_path, 'Ramp.dae')) + ramp_name = 'Ramp/{}'.format(ramp.id) + bpy.context.active_object.name = ramp_name + obj = bpy.data.objects[ramp_name] + + obj.location = (ramp.centerPoint.x, ramp.centerPoint.y, 0) + obj.rotation_euler = [0, 0, ramp.orientation] + obj.scale[0] = 0.001 + obj.scale[1] = 0.001 + obj.scale[2] = 0.001 + scene_rgb.objects.link(obj) + + duplicate_add_segmentation("Seg-Ramp-{}".format(ramp.id), RAMP_COLOR, scene_seg) + diff --git a/blender/renderer/traffic_sign.py b/blender/renderer/traffic_sign.py new file mode 100644 index 0000000..347d3dc --- /dev/null +++ b/blender/renderer/traffic_sign.py @@ -0,0 +1,87 @@ +import bpy +from commonroad.renderer.traffic_sign import SIGN_MESHES +import os +from blender.renderer.segmentation_colormap import SIGN_BASE_COLOR, SIGN_TO_COLOR +from blender.renderer.segmentation_colormap import convert_to_one_range +from blender.renderer.utils import add_segmentation_mat, convert_mat_to_cycles +import numpy as np + + +def draw(sign, sign_mesh_path, scene_rgb, scene_seg, sign_idx=0): + bpy.ops.wm.collada_import(filepath=os.path.join(sign_mesh_path, + SIGN_MESHES[sign.type]['mesh'] + '.dae')) + sign_mesh_names = [] + print('Selected objects: {}'.format(bpy.context.selected_objects)) + for obj in bpy.context.selected_objects: + obj.name = obj.name.replace('Body', 'Seg-Sign/{}_{}'.format(sign.type, sign.id)) + # dae importer auto-renames the UV map, need to have uniform name to be able to merge + for uv_layer in obj.data.uv_layers: + uv_layer.name = 'UVMap' + for m_slot in obj.material_slots: + m_slot.material = convert_mat_to_cycles(m_slot.material) + sign_mesh_names.append(obj.name) + sign_mesh_names = sorted(sign_mesh_names) + bpy.ops.object.duplicate() + bpy.ops.object.join() + + sign_name = 'Sign/{}_{}'.format(sign.type, sign.id) + bpy.context.active_object.name = sign_name + obj = bpy.data.objects[sign_name] + + obj.location = (sign.centerPoint.x, sign.centerPoint.y, 0) + obj.rotation_euler = [0, 0, sign.orientation] + obj.scale[0] = 0.001 + obj.scale[1] = 0.001 + obj.scale[2] = 0.001 + obj.data.use_auto_smooth = True + scene_rgb.objects.link(obj) + + for idx, name in enumerate(sign_mesh_names[:-1]): + add_segmentation_mat(SIGN_BASE_COLOR, "Seg-Mat/Seg-Sign-Base/{}_{}_{}".format(sign.type, sign.id, idx), + bpy.data.objects[name]) + + # for segmentation: label the forward-facing faces of label mesh only + add_segmentation_mat(SIGN_TO_COLOR[sign.type], + "Seg-Mat/Seg-Sign-Base/{}_{}_{}".format(sign.type, sign.id, len(sign_mesh_names)-1), + bpy.data.objects[sign_mesh_names[-1]]) + sign_mesh = bpy.data.objects[sign_mesh_names[-1]].data + # other local coordinate system for "Vorbeifahrt rechts" sign + if sign.type == 'stvo-222': + forward_normal_dir = (0.0, -1.0, 0.0) + else: + forward_normal_dir = (1.0, 0.0, 0.0) + for face in sign_mesh.polygons: + if np.linalg.norm(np.array(tuple(face.normal)) - np.array(forward_normal_dir)) < 0.1: + face.material_index = 0 + else: + face.material_index = 1 + + mat = bpy.data.materials.new(name="Seg-Mat/Seg-Sign-Base/{}_{}_{}-backside_color".format(sign.type, sign.id, + len(sign_mesh_names)-1)) + mat.diffuse_color = convert_to_one_range(SIGN_BASE_COLOR) + mat.use_shadeless = True + obj.data.materials.append(mat) + + bpy.ops.object.select_all(action='DESELECT') + + bpy.context.scene.objects.active = bpy.data.objects[sign_mesh_names[0]] + for sign_mesh_name in sign_mesh_names: + bpy.data.objects[sign_mesh_name].select = True + bpy.ops.object.join() + + sign_name = 'Seg-Sign/{}_{}'.format(sign.type, sign.id) + ctx = bpy.context.copy() + ctx['active_object'].name = sign_name + obj = bpy.data.objects[sign_name] + + obj.location = (sign.centerPoint.x, sign.centerPoint.y, 0) + obj.rotation_euler = [0, 0, sign.orientation] + obj.scale[0] = 0.001 + obj.scale[1] = 0.001 + obj.scale[2] = 0.001 + # pass index for instance IDs + obj.data.use_auto_smooth = True + obj.pass_index = sign_idx + last_mat_name = sorted([slot.material.name for slot in obj.material_slots])[-1] + bpy.data.materials[last_mat_name].pass_index = sign_idx + scene_seg.objects.link(obj) diff --git a/blender/renderer/utils.py b/blender/renderer/utils.py new file mode 100644 index 0000000..a25ac64 --- /dev/null +++ b/blender/renderer/utils.py @@ -0,0 +1,74 @@ +import bpy +import os +from blender.renderer.segmentation_colormap import convert_to_one_range + + +def duplicate_add_segmentation(obj_name, mat_color, scene_seg): + bpy.ops.object.duplicate() + bpy.context.active_object.name = obj_name + seg_obj = bpy.data.objects[obj_name] + add_segmentation_mat(mat_color, 'Seg-Mat/'+obj_name, seg_obj) + scene_seg.objects.link(seg_obj) + + +def add_segmentation_mat(mat_color, mat_name, obj): + mat = bpy.data.materials.new(name=mat_name) + mat.diffuse_color = convert_to_one_range(mat_color) + mat.use_shadeless = True + for i in range(len(obj.material_slots)): + bpy.ops.object.material_slot_remove({'object': obj}) + obj.data.materials.append(mat) + + +def generate_material_cycles(material_name, filename, shader_type='ShaderNodeBsdfDiffuse'): + bpy.context.scene.render.engine = 'CYCLES' + mat = bpy.data.materials.new(material_name) + mat.use_nodes = True + matnodes = mat.node_tree.nodes + + tex = matnodes.new('ShaderNodeTexImage') + tex.image = bpy.data.images[os.path.basename(filename)] + + if shader_type != "ShaderNodeBsdfDiffuse": + shader_node = matnodes.new(shader_type) + else: + shader_node = matnodes['Diffuse BSDF'] + + # link color + mat.node_tree.links.new(tex.outputs['Color'], shader_node.inputs['Color']) + mat.node_tree.links.new(shader_node.outputs['BSDF'], + matnodes['Material Output'].inputs['Surface']) + return mat + + +def convert_mat_to_cycles(mat): + # other texture slots are dummy placeholders in most cases + texture = mat.texture_slots[0].texture + + bpy.context.scene.render.engine = 'CYCLES' + mat.use_nodes = True + matnodes = mat.node_tree.nodes + + tex = matnodes.new('ShaderNodeTexImage') + tex.image = texture.image + mat.node_tree.links.new(tex.outputs['Color'], matnodes['Diffuse BSDF'].inputs['Color']) + mat.node_tree.links.new(matnodes['Diffuse BSDF'].outputs['BSDF'], + matnodes['Material Output'].inputs['Surface']) + return mat + + +def generate_material_internal_segmentation(material_name, filename): + bpy.data.textures.new(os.path.basename(filename), type='IMAGE') + bpy.data.textures[os.path.basename(filename)].image = bpy.data.images[os.path.basename(filename)] + bpy.data.textures[os.path.basename(filename)].extension = 'CLIP' + bpy.data.textures[os.path.basename(filename)].use_interpolation = False + bpy.data.textures[os.path.basename(filename)].filter_size = 0.10 + bpy.data.textures[os.path.basename(filename)].image.colorspace_settings.name = 'Raw' + + bpy.data.materials.new(material_name) + mat = bpy.data.materials[material_name] + mat.use_shadeless = True + slot = mat.texture_slots.add() + slot.texture = bpy.data.textures[os.path.basename(filename)] + slot.texture_coords = 'ORCO' + return mat \ No newline at end of file diff --git a/blender/segmentation_masks/realsense_segmentation_mask.png b/blender/segmentation_masks/realsense_segmentation_mask.png new file mode 100644 index 0000000..99d7257 Binary files /dev/null and b/blender/segmentation_masks/realsense_segmentation_mask.png differ diff --git a/blender/segmentation_masks/top_segmentation_mask.png b/blender/segmentation_masks/top_segmentation_mask.png new file mode 100644 index 0000000..0fd2696 Binary files /dev/null and b/blender/segmentation_masks/top_segmentation_mask.png differ diff --git a/commonroad/__init__.py b/commonroad/__init__.py old mode 100644 new mode 100755 diff --git a/commonroad/generator/__init__.py b/commonroad/generator/__init__.py old mode 100644 new mode 100755 diff --git a/commonroad/generator/preset_parser.py b/commonroad/generator/preset_parser.py old mode 100644 new mode 100755 index fc89836..e463f52 --- a/commonroad/generator/preset_parser.py +++ b/commonroad/generator/preset_parser.py @@ -38,6 +38,10 @@ def eval_element(el): return [ primitive.BlockedAreaObstacle(el.attrib) ] + elif el.tag == "trafficIsland": + return [ + primitive.TrafficIsland(el.attrib) + ] elif el.tag == "intersection": return [ primitive.Intersection(el.attrib) @@ -50,6 +54,10 @@ def eval_element(el): return [ primitive.TrafficSign(el.attrib) ] + elif el.tag == "ramp": + return [ + primitive.Ramp(el.attrib) + ] elif el.tag == "zebraCrossing": return [ primitive.ZebraCrossing(el.attrib) diff --git a/commonroad/generator/primitive.py b/commonroad/generator/primitive.py old mode 100644 new mode 100755 index 4ba55dc..f586010 --- a/commonroad/generator/primitive.py +++ b/commonroad/generator/primitive.py @@ -3,6 +3,10 @@ from shapely.geometry import LineString, CAP_STYLE, JOIN_STYLE import scipy.integrate as integrate from commonroad import schema +from functools import partial +from scipy.optimize import root_scalar + +RENDER_OFFSET_RELATIVE = 0 class MissingPointsException(Exception): pass @@ -96,12 +100,15 @@ def export(self, config): left = p1 + ortho_left right = p1 + ortho_right + precision_scale = RENDER_OFFSET_RELATIVE lanelet1.leftBoundary.point.append( - schema.point(x=points[i][0], y=points[i][1])) + schema.point(x=points[i][0] + ortho_left[0] * precision_scale, + y=points[i][1] + ortho_left[1] * precision_scale)) lanelet1.rightBoundary.point.append( schema.point(x=right[0], y=right[1])) lanelet2.leftBoundary.point.append( - schema.point(x=points[i][0], y=points[i][1])) + schema.point(x=points[i][0] + ortho_right[0] * precision_scale, + y=points[i][1] + ortho_right[1] * precision_scale)) lanelet2.rightBoundary.point.append( schema.point(x=left[0], y=left[1])) # TODO add last point @@ -181,7 +188,25 @@ def export(self, config): transformed = self._transform_point([x, y]) obj.orientation += self._angle obj.centerPoint = schema.point(x=transformed[0], y=transformed[1]) - + elif isinstance(obj, schema.ramp): + x = obj.centerPoint.x + y = obj.centerPoint.y + transformed = self._transform_point([x, y]) + obj.orientation += self._angle + obj.centerPoint = schema.point(x=transformed[0], y=transformed[1]) + elif isinstance(obj, schema.trafficIslandJunction): + for i in range(len(obj.point)): + x = obj.point[i].x + y = obj.point[i].y + transformed = self._transform_point([x, y]) + obj.point[i].x = transformed[0] + obj.point[i].y = transformed[1] + elif isinstance(obj, schema.roadMarking): + x = obj.centerPoint.x + y = obj.centerPoint.y + transformed = self._transform_point([x, y]) + obj.orientation += self._angle + obj.centerPoint = schema.point(x=transformed[0], y=transformed[1]) return export class StraightLine(Primitive): @@ -287,6 +312,15 @@ def __init__(self, args): def get_points(self): return self._points +def _compute_cubic_bezier(t, p0, p1, p2, p3): + c0 = (1 - t) * p0 + t * p1 + c1 = (1 - t) * p1 + t * p2 + c2 = (1 - t) * p2 + t * p3 + d0 = (1 - t) * c0 + t * c1 + d1 = (1 - t) * c1 + t * c2 + x = (1 - t) * d0 + t * d1 + return x + class CubicBezier(Primitive): def __init__(self, args): self._p0 = np.array([0, 0]) @@ -300,13 +334,7 @@ def __init__(self, args): self._points = [] t = 0 while t <= 1: - c0 = (1-t) * self._p0 + t * self._p1 - c1 = (1-t) * self._p1 + t * self._p2 - c2 = (1-t) * self._p2 + t * self._p3 - d0 = (1-t) * c0 + t * c1 - d1 = (1-t) * c1 + t * c2 - x = (1-t) * d0 + t * d1 - self._points.append(x) + self._points.append(_compute_cubic_bezier(t, self._p0, self._p1, self._p2, self._p3)) t += 0.01 def get_points(self): @@ -381,11 +409,15 @@ def get_ending(self): return (np.array([0, self._size]), 0.5 * math.pi, 0) def export(self, config): + # small offset added for clean segmentation lanes + # (otherwise there is visible imprecision due to floating-point errors) + rendering_offset = RENDER_OFFSET_RELATIVE * config.road_width + southRight = schema.lanelet(leftBoundary=schema.boundary(), rightBoundary=schema.boundary()) southRight.leftBoundary.lineMarking = "dashed" southRight.rightBoundary.lineMarking = "solid" - southRight.leftBoundary.point.append(schema.point(x=0, y=-self._size)) - southRight.leftBoundary.point.append(schema.point(x=0, y=-config.road_width)) + southRight.leftBoundary.point.append(schema.point(x=-rendering_offset, y=-self._size)) + southRight.leftBoundary.point.append(schema.point(x=-rendering_offset, y=-config.road_width)) southRight.rightBoundary.point.append(schema.point(x=config.road_width, y=-self._size)) southRight.rightBoundary.point.append(schema.point(x=config.road_width, y=-config.road_width)) @@ -399,15 +431,15 @@ def export(self, config): northRight = schema.lanelet(leftBoundary=schema.boundary(), rightBoundary=schema.boundary()) northRight.leftBoundary.lineMarking = "dashed" northRight.rightBoundary.lineMarking = "solid" - northRight.leftBoundary.point.append(schema.point(x=0, y=self._size)) - northRight.leftBoundary.point.append(schema.point(x=0, y=config.road_width)) + northRight.leftBoundary.point.append(schema.point(x=-rendering_offset, y=self._size)) + northRight.leftBoundary.point.append(schema.point(x=-rendering_offset, y=config.road_width)) northRight.rightBoundary.point.append(schema.point(x=-config.road_width, y=self._size)) northRight.rightBoundary.point.append(schema.point(x=-config.road_width, y=config.road_width)) northLeft = schema.lanelet(leftBoundary=schema.boundary(), rightBoundary=schema.boundary()) northLeft.rightBoundary.lineMarking = "solid" - northLeft.leftBoundary.point.append(schema.point(x=0, y=config.road_width)) - northLeft.leftBoundary.point.append(schema.point(x=0, y=self._size)) + northLeft.leftBoundary.point.append(schema.point(x=-rendering_offset - 3E-3, y=config.road_width)) + northLeft.leftBoundary.point.append(schema.point(x=-rendering_offset - 3E-3, y=self._size)) northLeft.rightBoundary.point.append(schema.point(x=config.road_width, y=config.road_width)) northLeft.rightBoundary.point.append(schema.point(x=config.road_width, y=self._size)) @@ -421,8 +453,8 @@ def export(self, config): eastLeft = schema.lanelet(leftBoundary=schema.boundary(), rightBoundary=schema.boundary()) eastLeft.rightBoundary.lineMarking = "solid" eastLeft.leftBoundary.lineMarking = "dashed" - eastLeft.leftBoundary.point.append(schema.point(x=config.road_width, y=0)) - eastLeft.leftBoundary.point.append(schema.point(x=self._size, y=0)) + eastLeft.leftBoundary.point.append(schema.point(x=config.road_width, y=rendering_offset)) + eastLeft.leftBoundary.point.append(schema.point(x=self._size, y=rendering_offset)) eastLeft.rightBoundary.point.append(schema.point(x=config.road_width, y=-config.road_width)) eastLeft.rightBoundary.point.append(schema.point(x=self._size, y=-config.road_width)) @@ -436,8 +468,8 @@ def export(self, config): westLeft = schema.lanelet(leftBoundary=schema.boundary(), rightBoundary=schema.boundary()) westLeft.leftBoundary.lineMarking = "dashed" westLeft.rightBoundary.lineMarking = "solid" - westLeft.leftBoundary.point.append(schema.point(x=-config.road_width, y=0)) - westLeft.leftBoundary.point.append(schema.point(x=-self._size, y=0)) + westLeft.leftBoundary.point.append(schema.point(x=-config.road_width, y=-rendering_offset)) + westLeft.leftBoundary.point.append(schema.point(x=-self._size, y=-rendering_offset)) westLeft.rightBoundary.point.append(schema.point(x=-config.road_width, y=config.road_width)) westLeft.rightBoundary.point.append(schema.point(x=-self._size, y=config.road_width)) @@ -461,6 +493,13 @@ def export(self, config): result = [southRight, southLeft, northLeft, northRight, eastLeft, eastRight, westLeft, westRight] + # intersection obstacle + rect = schema.rectangle(length=config.road_width * 2, + width=config.road_width * 2, orientation=0, + centerPoint=schema.point(x=0, y=0)) + obstacle = schema.obstacle(role="static", type="segmentationIntersection", shape=schema.shape()) + obstacle.shape.rectangle.append(rect) + result.append(obstacle) pairs = [(southRight, southLeft)] if self._target_dir == "left": @@ -484,7 +523,23 @@ def export(self, config): pairs.append((westLeft, westRight)) result.append(schema.trafficSign(type="stvo-209-10", orientation=math.pi*1.5, centerPoint=schema.point( - x=config.road_width + 0.1, y= -config.road_width - 0.25))) + x=config.road_width + 0.1, y=-config.road_width - 0.25))) + result.append(schema.roadMarking(type=schema.roadMarkingType.turn_right, + orientation=math.pi, + centerPoint=schema.point(x=(config.road_width + + config.turn_road_marking_width) * 0.5, + y=-config.road_width - 0.25) + )) + if self._rule != 'yield': + result.append(schema.roadMarking(type=schema.roadMarkingType.turn_left, + orientation=math.pi * 0.5, + centerPoint=schema.point(x=-config.road_width - 0.25, + y=-(config.road_width + + config.turn_road_marking_width) * 0.5) + )) + result.append(schema.trafficSign(type="stvo-209-20", + orientation=math.pi, centerPoint=schema.point( + x=-config.road_width - 0.25, y=-config.road_width - 0.1))) elif self._target_dir == "right": right_lanelet = schema.lanelet(leftBoundary=schema.boundary(), rightBoundary=schema.boundary()) right_lanelet.leftBoundary.lineMarking = "dashed" @@ -506,7 +561,22 @@ def export(self, config): pairs.append((eastLeft, eastRight)) result.append(schema.trafficSign(type="stvo-209-20", orientation=math.pi*1.5, centerPoint=schema.point( - x=config.road_width + 0.1, y= -config.road_width - 0.25))) + x=config.road_width + 0.1, y=-config.road_width - 0.25))) + result.append(schema.roadMarking(type=schema.roadMarkingType.turn_left, + orientation=math.pi, + centerPoint=schema.point(x=(config.road_width + + config.turn_road_marking_width) * 0.5, + y=-config.road_width - 0.25))) + if self._rule != 'yield': + result.append(schema.roadMarking(type=schema.roadMarkingType.turn_right, + orientation=math.pi * 1.5, + centerPoint=schema.point(x=config.road_width + 0.25, + y=(config.road_width + + config.turn_road_marking_width) * 0.5) + )) + result.append(schema.trafficSign(type="stvo-209-10", + orientation=0, centerPoint=schema.point( + x=config.road_width + 0.25, y=config.road_width + 0.1))) elif self._target_dir == "straight": right_lanelet = schema.lanelet(leftBoundary=schema.boundary(), rightBoundary=schema.boundary()) right_lanelet.rightBoundary.point.append(schema.point(x=config.road_width, y=-config.road_width)) @@ -529,6 +599,21 @@ def export(self, config): result.append(schema.trafficSign(type=type_map[self._rule], orientation=math.pi*1.5, centerPoint=schema.point( x=config.road_width + 0.1, y= -config.road_width - 0.5))) + result.append(schema.trafficSign(type=type_map[self._rule], + orientation=math.pi*0.5, centerPoint=schema.point( + x=-config.road_width - 0.1, y= config.road_width + 0.5))) + + # stop, right of way, right of way, right of way + # todo: also add turning signal if we are not on the outer turn lane on the opposite side + type_map_opposite = {"priority-yield":"stvo-206", "priority-stop":"stvo-306", + "yield":"stvo-306", "stop":"stvo-306"} + if self._rule in type_map: + result.append(schema.trafficSign(type=type_map_opposite[self._rule], + orientation=0, centerPoint=schema.point( + y=config.road_width + 0.1, x= config.road_width + 0.5))) + result.append(schema.trafficSign(type=type_map_opposite[self._rule], + orientation=math.pi, centerPoint=schema.point( + y=-config.road_width - 0.1, x= -config.road_width - 0.5))) return Export(result, pairs) @@ -638,12 +723,430 @@ class TrafficSign(StraightLine): def __init__(self, args): super().__init__(dict(length=0.01)) self._traffic_sign = args["type"] + self._on_opposite_side = False + if "on_opposite_side" in args: + self._on_opposite_side = args["on_opposite_side"] def export(self, config): - traffic_sign = schema.trafficSign(type=self._traffic_sign, - orientation=math.pi, centerPoint=schema.point(x=self._length / 2, - y=-config.road_width - 0.15)) + if self._on_opposite_side: + traffic_sign = schema.trafficSign(type=self._traffic_sign, + orientation=0.0, centerPoint=schema.point(x=self._length / 2, + y=config.road_width + 0.15)) + else: + traffic_sign = schema.trafficSign(type=self._traffic_sign, + orientation=math.pi, centerPoint=schema.point(x=self._length / 2, + y=-config.road_width - 0.15)) export = super().export(config) export.objects.append(traffic_sign) + + if self._traffic_sign in [str(item)[1:-1] for item in schema.roadMarkingType.items()]: + road_marking = schema.roadMarking(type=schema.roadMarkingType(self._traffic_sign), orientation=-math.pi/2, + centerPoint=schema.point(x=self._length / 2, y=-config.road_width/2)) + export.objects.append(road_marking) return export + +class Ramp(StraightLine): + def __init__(self, args): + self._signDistance = float(args["signDistance"]) + self._padding = 0.4 + # length of current ramp .DAE + the signs we put around + super().__init__(dict(length=1.8+float(args["signDistance"])*2+2*self._padding)) + + def export(self, config): + ramp = schema.ramp(orientation=math.pi, centerPoint=schema.point(x=self._signDistance+self._padding, y=0)) + + export = super().export(config) + export.objects.append(ramp) + export.objects.append(schema.trafficSign(type="stvo-110-10", orientation=math.pi, + centerPoint=schema.point(x=self._padding, + y=-config.road_width - 0.1))) + export.objects.append(schema.trafficSign(type="stvo-108-10", orientation=math.pi, + centerPoint=schema.point(x=self._length-self._padding, + y=-config.road_width - 0.1))) + export.objects.append(schema.trafficSign(type="stvo-108-10", orientation=0, + centerPoint=schema.point(x=self._padding, + y=config.road_width + 0.1))) + export.objects.append(schema.trafficSign(type="stvo-110-10", orientation=0, + centerPoint=schema.point(x=self._length-self._padding, + y=config.road_width + 0.1))) + return export + +def add_quad_bezier_points(lanelet_points, t_step, p0, p1, p2, p3): + t = 0.0 + while t <= 1: + point = _compute_cubic_bezier(t, p0, p1, p2, p3) + lanelet_points.append(schema.point(x=point[0], y=point[1])) + t += t_step + +def quad_bezier_line_intersection(p0, p1, p2, p3, A, d): + coefficients = [] + # t^3 coefficients + coefficients.append(-(A * p0) + 3 *(A * p1) - 3 * (A * p2) + A * p3) + # t^2 coefficients + coefficients.append(3 * A * p0 - 6 * A * p1 + 3 * A * p2) + # t coefficients + coefficients.append(-3 * A * p0 - 3 * A * p1) + # free coefficients + coefficients.append(A * p0 - d) + print('shape', np.array(coefficients).shape) + print(np.array(coefficients)) + return np.roots(np.array(coefficients)) + +def quad_bezier_line_function(t, p0, p1, p2, p3, A, d): + return (1 - t) ** 3 * np.dot(A, p0) + 3 * (1 - t) ** 2 * t * np.dot(A, p1) + 3 * (1 - t) * t ** 2 * np.dot(A, p2) + \ + t ** 3 * np.dot(A, p3) - d + +class TrafficIsland(Primitive): + def __init__(self, args): + self._islandWidth = float(args["islandWidth"]) + self._zebraLength = float(args["zebraLength"]) + self._signDistance = float(args["signDistance"]) + self._zebraMarkingType = args["zebraMarkingType"] + self._padding = 0.2 + self._curve_area_length = 0.8 + self._length = self._padding * 2 + self._curve_area_length * 2 + self._zebraLength + # super().__init__(dict(length=self._length)) + points = self.get_points() + self._principal_direction = np.array([points[1][0] - points[0][0], + points[1][1] - points[0][1]]) + self._principal_direction = self._principal_direction/np.linalg.norm(self._principal_direction) + self._orthogonal_direction = np.array([-self._principal_direction[1], self._principal_direction[0]]) + self._orthogonal_direction = self._orthogonal_direction/np.linalg.norm(self._orthogonal_direction) + + def get_points(self): + return [[0, 0], [self._length, 0]] + + def get_beginning(self): + return (np.array([0, 0]), math.pi, 0) + + def get_ending(self): + return (np.array([self._length + self._zebraLength, 0]), 0, 0) + + def export(self, config): + points = self.get_points() + + # straight padding lines + padding_right = schema.lanelet(leftBoundary=schema.boundary(), rightBoundary=schema.boundary()) + padding_left = schema.lanelet(leftBoundary=schema.boundary(), rightBoundary=schema.boundary()) + padding_right.rightBoundary.lineMarking = "solid" + padding_right.leftBoundary.lineMarking = "dashed" + padding_left.rightBoundary.lineMarking = "solid" + padding_left.leftBoundary.lineMarking = "dashed" + padding_right.leftBoundary.point.append(schema.point(x=points[0][0], y=points[0][1])) + padding_left.leftBoundary.point.append(schema.point(x=points[0][0], y=points[0][1])) + starting_point = np.array(points[0]) + right_starting_point = starting_point - self._orthogonal_direction * config.road_width + padding_right.rightBoundary.point.append(schema.point(x=right_starting_point[0], y=right_starting_point[1])) + left_starting_point = starting_point + self._orthogonal_direction * config.road_width + padding_left.rightBoundary.point.append(schema.point(x=left_starting_point[0], y=left_starting_point[1])) + + # cubic beziers connecting to zebra section + split_right = schema.lanelet(leftBoundary=schema.boundary(), rightBoundary=schema.boundary()) + split_right.rightBoundary.lineMarking = "solid" + split_right.leftBoundary.lineMarking = "solid" + + split_left = schema.lanelet(leftBoundary=schema.boundary(), rightBoundary=schema.boundary()) + split_left.rightBoundary.lineMarking = "solid" + split_left.leftBoundary.lineMarking = "solid" + + split_starting_point = starting_point + self._principal_direction * self._padding + split_right.leftBoundary.point.append(schema.point(x=split_starting_point[0], y=split_starting_point[1])) + split_left.leftBoundary.point.append(schema.point(x=split_starting_point[0], y=split_starting_point[1])) + right_split_starting = split_starting_point - self._orthogonal_direction * config.road_width + split_right.rightBoundary.point.append(schema.point(x=right_split_starting[0], y=right_split_starting[1])) + left_split_starting = split_starting_point + self._orthogonal_direction * config.road_width + split_left.rightBoundary.point.append(schema.point(x=left_split_starting[0], y=left_split_starting[1])) + + padding_right.leftBoundary.point.append(schema.point(x=split_starting_point[0], y=split_starting_point[1])) + padding_left.leftBoundary.point.append(schema.point(x=split_starting_point[0], y=split_starting_point[1])) + padding_right.rightBoundary.point.append(schema.point(x=right_split_starting[0], y=right_split_starting[1])) + padding_left.rightBoundary.point.append(schema.point(x=left_split_starting[0], y=left_split_starting[1])) + padding_left.leftBoundary.point.reverse() + padding_left.rightBoundary.point.reverse() + + zebra_start_right_center = split_starting_point + self._principal_direction * self._curve_area_length \ + - self._orthogonal_direction * self._islandWidth * 0.5 + zebra_start_right_outer = split_starting_point + self._principal_direction * self._curve_area_length \ + - self._orthogonal_direction * (self._islandWidth * 0.5 + config.road_width) + p1_offset = 0.2 + t_step = 0.01 + right_center_p0 = split_starting_point + right_center_p1 = split_starting_point + self._principal_direction * p1_offset + right_center_p2 = zebra_start_right_center - self._principal_direction * p1_offset + right_center_p3 = zebra_start_right_center + add_quad_bezier_points(split_right.leftBoundary.point, t_step, right_center_p0, right_center_p1, + right_center_p2, right_center_p3) + + right_outer_p0 = right_split_starting + right_outer_p1 = right_split_starting + self._principal_direction * p1_offset + right_outer_p2 = zebra_start_right_outer - self._principal_direction * p1_offset + right_outer_p3 = zebra_start_right_outer + add_quad_bezier_points(split_right.rightBoundary.point, t_step, right_outer_p0, right_outer_p1, right_outer_p2, + right_outer_p3) + + # left lanelet + zebra_start_left_center = split_starting_point + self._principal_direction * self._curve_area_length \ + + self._orthogonal_direction * self._islandWidth * 0.5 + zebra_start_left_outer = split_starting_point + self._principal_direction * self._curve_area_length \ + + self._orthogonal_direction * (self._islandWidth * 0.5 + config.road_width) + left_center_p0 = split_starting_point + left_center_p1 = split_starting_point + self._principal_direction * p1_offset + left_center_p2 = zebra_start_left_center - self._principal_direction * p1_offset + left_center_p3 = zebra_start_left_center + add_quad_bezier_points(split_left.leftBoundary.point, t_step, left_center_p0, left_center_p1, left_center_p2, + left_center_p3) + + left_outer_p0 = left_split_starting + left_outer_p1 = left_split_starting + self._principal_direction * p1_offset + left_outer_p2 = zebra_start_left_outer - self._principal_direction * p1_offset + left_outer_p3 = zebra_start_left_outer + add_quad_bezier_points(split_left.rightBoundary.point, t_step, left_outer_p0, left_outer_p1, left_outer_p2, + left_outer_p3) + + # populate center blocked area object + starting_junction = schema.trafficIslandJunction() + starting_junction.point.append(schema.point(x=zebra_start_right_center[0], y=zebra_start_right_center[1])) + starting_junction.point.append(schema.point(x=zebra_start_left_center[0], y=zebra_start_left_center[1])) + + A = np.zeros(2) + A[0] = math.sin(27 / 180 * math.pi) + A[1] = math.cos(27 / 180 * math.pi) + for y in np.arange(zebra_start_right_center[1], zebra_start_left_center[1], + 0.15 * math.tan(27 / 180 * math.pi)): + d = zebra_start_right_center[0] * A[0] + y * A[1] + sol = root_scalar(partial(quad_bezier_line_function, p0=left_center_p0, p1=left_center_p1, + p2=left_center_p2, p3=left_center_p3, A=A, d=d), bracket=[0, 1], method='brentq') + sol_point = _compute_cubic_bezier(sol.root, left_center_p0, left_center_p1, left_center_p2, left_center_p3) + starting_junction.point.append(schema.point(x=zebra_start_right_center[0], y=y)) + starting_junction.point.append(schema.point(x=sol_point[0], y=sol_point[1])) + + y = zebra_start_right_center[1] + for x in np.arange(zebra_start_right_center[0], split_starting_point[0], -0.15): + d = x * A[0] + y * A[1] + try: + sol_right = root_scalar(partial(quad_bezier_line_function, p0=right_center_p0, p1=right_center_p1, + p2=right_center_p2, p3=right_center_p3, A=A, d=d), + bracket=[0, 1], method='brentq') + except ValueError: + # in case we have went too low and there is no intersections, skip + continue + sol_point_right = _compute_cubic_bezier(sol_right.root, right_center_p0, right_center_p1, right_center_p2, + right_center_p3) + starting_junction.point.append(schema.point(x=sol_point_right[0], y=sol_point_right[1])) + + sol_left = root_scalar(partial(quad_bezier_line_function, p0=left_center_p0, p1=left_center_p1, + p2=left_center_p2, p3=left_center_p3, A=A, d=d), bracket=[0, 1], + method='brentq') + sol_point_left = _compute_cubic_bezier(sol_left.root, left_center_p0, left_center_p1, left_center_p2, + left_center_p3) + starting_junction.point.append(schema.point(x=sol_point_left[0], y=sol_point_left[1])) + + if self._zebraMarkingType == "lines": + split_right.stopLine = "dashed" + split_right.stopLineAttributes = schema.lineMarkingAttributes(lineWidth=0.02, segmentLength=0.04, + segmentGap=0.04) + + # zebra + zebra_start_right_center = zebra_start_right_center + zebra_start_right_outer = zebra_start_right_outer + zebra_end_right_center = zebra_start_right_center + self._principal_direction * self._zebraLength + zebra_end_right_outer = zebra_start_right_outer + self._principal_direction * self._zebraLength + + zebra_start_left_center = zebra_start_left_center + zebra_start_left_outer = zebra_start_left_outer + zebra_end_left_center = zebra_start_left_center + self._principal_direction * self._zebraLength + zebra_end_left_outer = zebra_start_left_outer + self._principal_direction * self._zebraLength + + crossing_right = schema.lanelet(leftBoundary=schema.boundary(), rightBoundary=schema.boundary()) + crossing_left = schema.lanelet(leftBoundary=schema.boundary(), rightBoundary=schema.boundary()) + + if self._zebraMarkingType == "zebra": + split_right.rightBoundary.point.append(schema.point(x=zebra_end_right_outer[0], + y=zebra_end_right_outer[1])) + split_right.leftBoundary.point.append(schema.point(x=zebra_end_right_center[0], + y=zebra_end_right_center[1])) + split_left.rightBoundary.point.append(schema.point(x=zebra_end_left_outer[0], + y=zebra_end_left_outer[1])) + split_left.leftBoundary.point.append(schema.point(x=zebra_end_left_center[0], + y=zebra_end_left_center[1])) + + crossing_right.type = "zebraCrossing" + crossing_right.leftBoundary.point.append(schema.point(x=zebra_start_right_center[0], + y=zebra_start_right_center[1])) + crossing_right.leftBoundary.point.append(schema.point(x=zebra_start_right_outer[0], + y=zebra_start_right_outer[1])) + crossing_right.rightBoundary.point.append(schema.point(x=zebra_end_right_center[0], + y=zebra_end_right_center[1])) + crossing_right.rightBoundary.point.append(schema.point(x=zebra_end_right_outer[0], + y=zebra_end_right_outer[1])) + crossing_right.rightBoundary.type = '' + + crossing_left.type = "zebraCrossing" + crossing_left.leftBoundary.point.append(schema.point(x=zebra_start_left_center[0], + y=zebra_start_left_center[1])) + crossing_left.leftBoundary.point.append(schema.point(x=zebra_start_left_outer[0], + y=zebra_start_left_outer[1])) + crossing_left.rightBoundary.point.append(schema.point(x=zebra_end_left_center[0], + y=zebra_end_left_center[1])) + crossing_left.rightBoundary.point.append(schema.point(x=zebra_end_left_outer[0], + y=zebra_end_left_outer[1])) + elif self._zebraMarkingType == "lines": + crossing_right.rightBoundary.lineMarking = "solid" + crossing_right.leftBoundary.lineMarking = "solid" + crossing_right.leftBoundary.point.append(schema.point(x=zebra_start_right_center[0], + y=zebra_start_right_center[1])) + crossing_right.leftBoundary.point.append(schema.point(x=zebra_end_right_center[0], + y=zebra_end_right_center[1])) + crossing_right.rightBoundary.point.append(schema.point(x=zebra_start_right_outer[0], + y=zebra_start_right_outer[1])) + crossing_right.rightBoundary.point.append(schema.point(x=zebra_end_right_outer[0], + y=zebra_end_right_outer[1])) + crossing_right.stopLine = "dashed" + crossing_right.stopLineAttributes = split_right.stopLineAttributes + + crossing_left.rightBoundary.lineMarking = "solid" + crossing_left.leftBoundary.lineMarking = "solid" + crossing_left.leftBoundary.point.append(schema.point(x=zebra_start_left_center[0], + y=zebra_start_left_center[1])) + crossing_left.leftBoundary.point.append(schema.point(x=zebra_end_left_center[0], + y=zebra_end_left_center[1])) + crossing_left.rightBoundary.point.append(schema.point(x=zebra_start_left_outer[0], + y=zebra_start_left_outer[1])) + crossing_left.rightBoundary.point.append(schema.point(x=zebra_end_left_outer[0], + y=zebra_end_left_outer[1])) + crossing_left.leftBoundary.point.reverse() + crossing_left.rightBoundary.point.reverse() + crossing_left.stopLine = "dashed" + crossing_left.stopLineAttributes = split_right.stopLineAttributes + + split_left.leftBoundary.point.reverse() + split_left.rightBoundary.point.reverse() + + # quad beziers merging at the back + merge_right = schema.lanelet(leftBoundary=schema.boundary(), rightBoundary=schema.boundary()) + merge_right.rightBoundary.lineMarking = "solid" + merge_right.leftBoundary.lineMarking = "solid" + + merge_left = schema.lanelet(leftBoundary=schema.boundary(), rightBoundary=schema.boundary()) + merge_left.rightBoundary.lineMarking = "solid" + merge_left.leftBoundary.lineMarking = "solid" + + merge_right.leftBoundary.point.append(schema.point(x=zebra_end_right_center[0], y=zebra_end_right_center[1])) + merge_left.leftBoundary.point.append(schema.point(x=zebra_end_left_center[0], y=zebra_end_left_center[1])) + merge_right.rightBoundary.point.append(schema.point(x=zebra_end_right_outer[0], y=zebra_end_right_outer[1])) + merge_left.rightBoundary.point.append(schema.point(x=zebra_end_left_outer[0], y=zebra_end_left_outer[1])) + + merge_center = split_starting_point + self._principal_direction * (self._curve_area_length * 2 + + self._zebraLength) + merge_outer_right = merge_center - self._orthogonal_direction * config.road_width + merge_outer_left = merge_center + self._orthogonal_direction * config.road_width + + p1_offset = 0.4 + t_step = 0.01 + right_center_p0 = zebra_end_right_center + right_center_p1 = zebra_end_right_center + self._principal_direction * p1_offset + right_center_p2 = merge_center - self._principal_direction * p1_offset + right_center_p3 = merge_center + add_quad_bezier_points(merge_right.leftBoundary.point, t_step, right_center_p0, right_center_p1, + right_center_p2, right_center_p3) + right_outer_p0 = zebra_end_right_outer + right_outer_p1 = zebra_end_right_outer + self._principal_direction * p1_offset + right_outer_p2 = merge_outer_right - self._principal_direction * p1_offset + right_outer_p3 = merge_outer_right + add_quad_bezier_points(merge_right.rightBoundary.point, t_step, right_outer_p0, right_outer_p1, right_outer_p2, + right_outer_p3) + + # left lanelet + left_center_p0 = zebra_end_left_center + left_center_p1 = zebra_end_left_center + self._principal_direction * p1_offset + left_center_p2 = merge_center - self._principal_direction * p1_offset + left_center_p3 = merge_center + add_quad_bezier_points(merge_left.leftBoundary.point, t_step, left_center_p0, left_center_p1, left_center_p2, + left_center_p3) + + left_outer_p0 = zebra_end_left_outer + left_outer_p1 = zebra_end_left_outer + self._principal_direction * p1_offset + left_outer_p2 = merge_outer_left - self._principal_direction * p1_offset + left_outer_p3 = merge_outer_left + add_quad_bezier_points(merge_left.rightBoundary.point, t_step, left_outer_p0, left_outer_p1, left_outer_p2, + left_outer_p3) + + merge_left.leftBoundary.point.reverse() + merge_left.rightBoundary.point.reverse() + + if self._zebraMarkingType == "lines": + merge_left.stopLine = "dashed" + merge_left.stopLineAttributes = split_right.stopLineAttributes + + # junction object at the end + merging_junction = schema.trafficIslandJunction() + merging_junction.point.append(schema.point(x=zebra_end_right_center[0], y=zebra_end_right_center[1])) + merging_junction.point.append(schema.point(x=zebra_end_left_center[0], y=zebra_end_left_center[1])) + + A = np.zeros(2) + A[0] = -math.sin(27 / 180 * math.pi) + A[1] = math.cos(27 / 180 * math.pi) + for y in np.arange(zebra_end_right_center[1], zebra_end_left_center[1], 0.15 * math.tan(27 / 180 * math.pi)): + d = zebra_end_right_center[0] * A[0] + y * A[1] + sol = root_scalar(partial(quad_bezier_line_function, p0=left_center_p0, p1=left_center_p1, + p2=left_center_p2, p3=left_center_p3, A=A, d=d), bracket=[0, 1], method='brentq') + sol_point = _compute_cubic_bezier(sol.root, left_center_p0, left_center_p1, left_center_p2, left_center_p3) + starting_junction.point.append(schema.point(x=zebra_end_right_center[0], y=y)) + starting_junction.point.append(schema.point(x=sol_point[0], y=sol_point[1])) + + y = zebra_end_right_center[1] + for x in np.arange(zebra_end_right_center[0], merge_center[0], 0.15): + d = x * A[0] + y * A[1] + try: + sol_right = root_scalar(partial(quad_bezier_line_function, p0=right_center_p0, p1=right_center_p1, + p2=right_center_p2, p3=right_center_p3, A=A, d=d), + bracket=[0, 1], method='brentq') + except ValueError: + # in case we have went too low and there is no intersections, skip + continue + sol_point_right = _compute_cubic_bezier(sol_right.root, right_center_p0, right_center_p1, right_center_p2, + right_center_p3) + starting_junction.point.append(schema.point(x=sol_point_right[0], y=sol_point_right[1])) + + sol_left = root_scalar(partial(quad_bezier_line_function, p0=left_center_p0, p1=left_center_p1, + p2=left_center_p2, p3=left_center_p3, A=A, d=d), bracket=[0, 1], + method='brentq') + sol_point_left = _compute_cubic_bezier(sol_left.root, left_center_p0, left_center_p1, left_center_p2, + left_center_p3) + starting_junction.point.append(schema.point(x=sol_point_left[0], y=sol_point_left[1])) + + # end straight padding lines + end_padding_right = schema.lanelet(leftBoundary=schema.boundary(), rightBoundary=schema.boundary()) + end_padding_left = schema.lanelet(leftBoundary=schema.boundary(), rightBoundary=schema.boundary()) + end_padding_right.rightBoundary.lineMarking = "solid" + end_padding_right.leftBoundary.lineMarking = "dashed" + end_padding_left.rightBoundary.lineMarking = "solid" + end_padding_left.leftBoundary.lineMarking = "dashed" + end_padding_right.leftBoundary.point.append(schema.point(x=merge_center[0], y=merge_center[1])) + end_padding_left.leftBoundary.point.append(schema.point(x=merge_center[0], y=merge_center[1])) + end_padding_right.rightBoundary.point.append(schema.point(x=merge_outer_right[0], y=merge_outer_right[1])) + end_padding_left.rightBoundary.point.append(schema.point(x=merge_outer_left[0], y=merge_outer_left[1])) + + end_center = merge_center + self._principal_direction * self._padding + end_right = end_center - self._orthogonal_direction * config.road_width + end_left = end_center + self._orthogonal_direction * config.road_width + + end_padding_right.leftBoundary.point.append(schema.point(x=end_center[0], y=end_center[1])) + end_padding_left.leftBoundary.point.append(schema.point(x=end_center[0], y=end_center[1])) + end_padding_right.rightBoundary.point.append(schema.point(x=end_right[0], y=end_right[1])) + end_padding_left.rightBoundary.point.append(schema.point(x=end_left[0], y=end_left[1])) + + export = Export([padding_right, padding_left, split_right, split_left, crossing_right, crossing_left, + merge_right, merge_left, end_padding_right, end_padding_left], + [(padding_right, padding_left), (split_right, split_left), (crossing_right, crossing_left), + (merge_right, merge_left), (end_padding_right, end_padding_left)]) + export.objects.append(schema.trafficSign(type="stvo-222", orientation=-math.pi/2, + centerPoint=schema.point(x=self._padding + self._signDistance, y=0.0))) + export.objects.append(schema.trafficSign(type="stvo-222", orientation=math.pi/2, + centerPoint=schema.point(x=self._length-self._padding - + self._signDistance, y=0.0))) + export.objects.append(starting_junction) + export.objects.append(merging_junction) + + return export \ No newline at end of file diff --git a/commonroad/generator/road_generation.py b/commonroad/generator/road_generation.py old mode 100644 new mode 100755 diff --git a/commonroad/generator/template-schema.xsd b/commonroad/generator/template-schema.xsd old mode 100644 new mode 100755 index dae50d9..60f3895 --- a/commonroad/generator/template-schema.xsd +++ b/commonroad/generator/template-schema.xsd @@ -18,14 +18,36 @@ + + + + + + + + + + + + + + + + + + + + + + @@ -101,6 +123,52 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -191,6 +259,8 @@ + + diff --git a/commonroad/renderer/__init__.py b/commonroad/renderer/__init__.py old mode 100644 new mode 100755 diff --git a/commonroad/renderer/ego_vehicle.py b/commonroad/renderer/ego_vehicle.py old mode 100644 new mode 100755 index a9c3b51..5dfaa54 --- a/commonroad/renderer/ego_vehicle.py +++ b/commonroad/renderer/ego_vehicle.py @@ -5,7 +5,7 @@ def draw(target_dir, lanelets): model_file = "car-cc2017.dae" model_stream = pkg_resources.resource_stream("commonroad.renderer.models", model_file) - with open(os.path.join(target_dir, model_file), "wb") as model_target: + with open(os.path.join(target_dir, 'meshes', model_file), "wb") as model_target: shutil.copyfileobj(model_stream, model_target) return """ @@ -86,22 +86,47 @@ def boundary_point_lengths(boundary): result.append(len) return result -def boundary_to_equi_distant(boundary): +def boundary_to_equi_distant(boundary, steps=20): lengths = boundary_point_lengths(boundary) x = list(map(lambda p: p.x, boundary.point)) y = list(map(lambda p: p.y, boundary.point)) - STEPS = 20 - eval_marks = np.arange(0, lengths[-1], lengths[-1]/STEPS) + # in the turning intersection we can have lanes where all boundary points on one side are in the same spot + if lengths[-1] == 0: + return [(boundary.point[0].x, boundary.point[0].y) for step in range(steps)] + + eval_marks = np.arange(0, lengths[-1], lengths[-1]/steps) xinterp = np.interp(eval_marks, lengths, x) yinterp = np.interp(eval_marks, lengths, y) - return map(lambda i: (i[0],i[1]), zip(xinterp, yinterp)) + return map(lambda i: (i[0], i[1]), zip(xinterp, yinterp)) + -def middle_of_lanelet(lanelet): - left = boundary_to_equi_distant(lanelet.leftBoundary) - right = boundary_to_equi_distant(lanelet.rightBoundary) +def middle_of_lanelet(lanelet, steps=20): + left = boundary_to_equi_distant(lanelet.leftBoundary, steps) + right = boundary_to_equi_distant(lanelet.rightBoundary, steps) return list(map(lambda p: ((p[0][0] + p[1][0])/2, (p[0][1] + p[1][1])/2), zip(left, right))) +def middle_point_lengths(points): + result = [0] + len = 0 + for (p1, p2) in zip(points, points[1:]): + len += math.sqrt((p2[0] - p1[0]) ** 2 + (p2[1] - p1[1]) ** 2) + result.append(len) + return result + +def middle_of_lanelet_equidistant(lanelet, step_length=0.5): + # just approximate middle line with a fixed number of points + left = boundary_to_equi_distant(lanelet.leftBoundary, 20) + right = boundary_to_equi_distant(lanelet.rightBoundary, 20) + middle = [((p_l[0] + p_r[0])/2, (p_l[1] + p_r[1])/2) for p_l, p_r in zip(left, right)] + lengths_middle = middle_point_lengths(middle) + result = [] + for l in np.arange(step_length, lengths_middle[-1], step_length): + point_base_idx = np.argwhere(lengths_middle < l)[-1][0] + point = np.array(middle[point_base_idx]) + (np.array(middle[point_base_idx + 1]) - np.array(middle[point_base_idx])) * (l - lengths_middle[point_base_idx]) + result.append(point) + return result + def get_lanelet_by_id(lanelet_list, id): for lanelet in lanelet_list: if lanelet.id == id: diff --git a/commonroad/renderer/fonts/DIN 1451 Std Engschrift.otf b/commonroad/renderer/fonts/DIN 1451 Std Engschrift.otf new file mode 100644 index 0000000..ae1412d Binary files /dev/null and b/commonroad/renderer/fonts/DIN 1451 Std Engschrift.otf differ diff --git a/commonroad/renderer/fonts/readme.html b/commonroad/renderer/fonts/readme.html new file mode 100644 index 0000000..fbacb63 --- /dev/null +++ b/commonroad/renderer/fonts/readme.html @@ -0,0 +1,188 @@ + + + + + + +Fontsgeek + + + + + + + + + + + + +
+ + +
+ + + + +
+

Downloaded from Fontsgeek.com

+

This font was downloaded from fontsgeek.com . You can visit fontsgeek.com for thousands of free fonts.

+

Browse other free fonts

+

You will be shortly redirected to fontsgeek.

+
+
+ + +
+ + + + \ No newline at end of file diff --git a/commonroad/renderer/groundplane.py b/commonroad/renderer/groundplane.py old mode 100644 new mode 100755 index 90b0083..ce419da --- a/commonroad/renderer/groundplane.py +++ b/commonroad/renderer/groundplane.py @@ -1,5 +1,6 @@ -#import cairo -import cairocffi as cairo +import cairo +# have to use pycairo instead of cairocffi as Rsvg bindings don't work with the latter +#import cairocffi as cairo import math from commonroad import utils from os import path @@ -7,11 +8,48 @@ import hashlib from tqdm import tqdm import numpy as np +from enum import Enum +from collections import namedtuple +import gi +gi.require_version('Rsvg', '2.0') +from gi.repository import Rsvg PIXEL_PER_UNIT = 500 TILE_SIZE = 2048 PADDING = 3 + +class MarkerImage(Enum): + TURN_LEFT = 'commonroad/renderer/street_markings/Fahrbahnmarkierung_Pfeil_L.svg' + TURN_RIGHT = 'commonroad/renderer/street_markings/Fahrbahnmarkierung_Pfeil_R.svg' + +StreetMarking = namedtuple('StreetMarking', ['marker_image', 'marker_text', 'crossed']) + + +ROADMARKING_TYPE_TO_VISUAL = { + "10_zone_beginn": StreetMarking(marker_image=None, marker_text='10', crossed=False), + "20_zone_beginn": StreetMarking(marker_image=None, marker_text='20', crossed=False), + "stvo-274.1": StreetMarking(marker_image=None, marker_text='30', crossed=False), + "40_zone_beginn": StreetMarking(marker_image=None, marker_text='40', crossed=False), + "50_zone_beginn": StreetMarking(marker_image=None, marker_text='50', crossed=False), + "60_zone_beginn": StreetMarking(marker_image=None, marker_text='60', crossed=False), + "70_zone_beginn": StreetMarking(marker_image=None, marker_text='70', crossed=False), + "80_zone_beginn": StreetMarking(marker_image=None, marker_text='80', crossed=False), + "90_zone_beginn": StreetMarking(marker_image=None, marker_text='90', crossed=False), + "ende_10_zone": StreetMarking(marker_image=None, marker_text='10', crossed=True), + "ende_20_zone": StreetMarking(marker_image=None, marker_text='20', crossed=True), + "stvo-274.2": StreetMarking(marker_image=None, marker_text='30', crossed=True), + "ende_40_zone": StreetMarking(marker_image=None, marker_text='40', crossed=True), + "ende_50_zone": StreetMarking(marker_image=None, marker_text='50', crossed=True), + "ende_60_zone": StreetMarking(marker_image=None, marker_text='60', crossed=True), + "ende_70_zone": StreetMarking(marker_image=None, marker_text='70', crossed=True), + "ende_80_zone": StreetMarking(marker_image=None, marker_text='80', crossed=True), + "ende_90_zone": StreetMarking(marker_image=None, marker_text='90', crossed=True), + "turn_left": StreetMarking(marker_image=MarkerImage.TURN_LEFT, marker_text=None, crossed=False), + "turn_right": StreetMarking(marker_image=MarkerImage.TURN_RIGHT, marker_text=None, crossed=False), +} + + def draw_boundary(ctx, boundary): if boundary.lineMarking is None: return @@ -32,19 +70,27 @@ def draw_stop_line(ctx, lanelet): p2 = lanelet.rightBoundary.point[-1] if lanelet.stopLine: + lineWidth = 0.04 + segmentLength = 0.08 + segmentGap = 0.06 if lanelet.stopLine == "dashed": - ctx.set_dash([0.08, 0.06]) + if lanelet.stopLineAttributes: + lineWidth = lanelet.stopLineAttributes.lineWidth + segmentLength = lanelet.stopLineAttributes.segmentLength + segmentGap = lanelet.stopLineAttributes.segmentGap + ctx.set_dash([segmentLength, segmentGap]) else: ctx.set_dash([]) ctx.set_line_cap(cairo.LINE_CAP_BUTT) - ctx.set_line_width(0.04) + ctx.set_line_width(lineWidth) ctx.move_to(p1.x, p1.y) ctx.line_to(p2.x, p2.y) ctx.stroke() ctx.restore() -def draw_rectangle(ctx, rectangle): +def draw_rectangle(ctx, rectangle, color=(1.0, 1.0, 1.0)): ctx.save() + ctx.set_source_rgb(*color) ctx.translate(rectangle.centerPoint.x, rectangle.centerPoint.y) ctx.rotate(-rectangle.orientation) ctx.rectangle(- rectangle.length / 2, - rectangle.width / 2, @@ -70,6 +116,69 @@ def draw_shape(ctx, shape): for poly in shape.polygon: draw_polygon(ctx, poly) +def draw_island_junction(ctx, island): + ctx.save() + ctx.set_dash([]) + ctx.set_line_width (0.02) + for i in range(0, len(island.point), 2): + ctx.move_to(island.point[i].x, island.point[i].y) + ctx.line_to(island.point[i+1].x, island.point[i+1].y) + ctx.stroke() + ctx.restore() + +def draw_road_marking(ctx, marking): + marking_visual = ROADMARKING_TYPE_TO_VISUAL[marking.type] + if marking_visual.marker_text: + ctx.save() + ctx.set_dash([]) + font = "DIN 1451 Std" + font_size = 0.4 + text = '30' + font_args = [cairo.FONT_SLANT_NORMAL] + ctx.translate(marking.centerPoint.x, #- 0.145*math.cos(marking.orientation), + marking.centerPoint.y) #- 0.145*math.sin(marking.orientation)) + ctx.rotate(marking.orientation) + # mirror text + ctx.transform(cairo.Matrix(1.0, 0, 0, -1, 0, 0)) + ctx.translate(-0.145, 0.29) + ctx.select_font_face(font, *font_args) + ctx.set_font_size(font_size) + ctx.text_path(marking_visual.marker_text) + ctx.set_line_width(0.01) + (x_bearing, y_bearing, text_width, text_height, + x_advance, y_advance) = ctx.text_extents(text) + ctx.fill_preserve() + ctx.stroke() + ctx.restore() + if marking_visual.crossed: + ctx.save() + ctx.move_to(marking.centerPoint.x + 0.145 * math.cos(marking.orientation), + marking.centerPoint.y + 0.145 * math.sin(marking.orientation)) + ctx.line_to(marking.centerPoint.x + 0.145 * math.cos(marking.orientation) + - text_height * math.cos(marking.orientation) + text_width * math.sin(marking.orientation), + marking.centerPoint.y + 0.145 * math.sin(marking.orientation) + - text_height * math.sin(marking.orientation) - text_width * math.cos(marking.orientation)) + ctx.move_to(marking.centerPoint.x + (0.145 - text_height) * math.cos(marking.orientation), + marking.centerPoint.y + (0.145 - text_height) * math.sin(marking.orientation)) + ctx.line_to(marking.centerPoint.x + 0.145 * math.cos(marking.orientation) + + text_width * math.sin(marking.orientation), + marking.centerPoint.y + 0.145 * math.sin(marking.orientation) + - text_width * math.cos(marking.orientation)) + ctx.set_line_width(0.05) + ctx.stroke() + ctx.restore() + + if marking_visual.marker_image: + ctx.save() + handle = Rsvg.Handle() + svg = handle.new_from_file(marking_visual.marker_image.value) + ctx.translate(marking.centerPoint.x, marking.centerPoint.y) + ctx.rotate(marking.orientation) + ctx.scale(0.001, 0.001) + svg.render_cairo(ctx) + ctx.restore() + + def draw_stripes_rect(ctx, rectangle): ctx.save() ctx.translate(rectangle.centerPoint.x, rectangle.centerPoint.y) @@ -143,14 +252,20 @@ def boundary_to_equi_distant(boundary, step_width, offset): yinterp = np.interp(eval_marks, lengths, y) return map(lambda i: (i[0],i[1]), zip(xinterp, yinterp)) -def draw_obstacle(ctx, obstacle): +def draw_obstacle(ctx, obstacle, color=(1.0, 1.0, 1,0)): if obstacle.type == "blockedArea": for rect in obstacle.shape.rectangle: draw_stripes_rect(ctx, rect) - else: - draw_shape(ctx, obstacle.shape) + # elif obstacle.type == "segmentationIntersection": + # for rect in obstacle.shape.rectangle: + # draw_rectangle(ctx, rect, color) + # uncomment if you want white boxes under the obstacles + #else: + # draw_shape(ctx, obstacle.shape) -def draw_all_boundaries(ctx, lanelet_list, boundary_name): + +def draw_all_boundaries(ctx, lanelet_list, boundary_name, color=(1, 1, 1)): + ctx.set_source_rgb(*color) all_ids = [lanelet.id for lanelet in lanelet_list if getattr(lanelet, boundary_name).lineMarking is not None] while len(all_ids) > 0: @@ -187,7 +302,7 @@ def get_lanelet_by_id(lanelet_list, id): return lanelet return None -def expand_boundary(lanelet_list, lanelet, boundary_name, direction): +def expand_boundary(lanelet_list, lanelet, boundary_name, direction, ignore_boundary=False): ids = [] original_line_type = getattr(lanelet, boundary_name).lineMarking found = True @@ -196,7 +311,7 @@ def expand_boundary(lanelet_list, lanelet, boundary_name, direction): if getattr(lanelet, direction) is not None: for next in getattr(lanelet, direction).lanelet: next_lanelet = get_lanelet_by_id(lanelet_list, next.ref) - if getattr(next_lanelet, boundary_name).lineMarking == original_line_type: + if getattr(next_lanelet, boundary_name).lineMarking == original_line_type or ignore_boundary: lanelet = next_lanelet ids.append(lanelet.id) found = True @@ -209,7 +324,6 @@ def draw(doc, target_dir): bounding_box.y_min -= PADDING bounding_box.x_max += PADDING bounding_box.y_max += PADDING - print(bounding_box) width = math.ceil((bounding_box.x_max - bounding_box.x_min) * PIXEL_PER_UNIT) height = math.ceil((bounding_box.y_max - bounding_box.y_min) * PIXEL_PER_UNIT) @@ -254,6 +368,12 @@ def draw(doc, target_dir): for obstacle in doc.obstacle: draw_obstacle(ctx, obstacle) + for island_junction in doc.islandJunction: + draw_island_junction(ctx, island_junction) + + for road_marking in doc.roadMarking: + draw_road_marking(ctx, road_marking) + sha_256 = hashlib.sha256() sha_256.update(surface.get_data()) hash = sha_256.hexdigest() @@ -337,6 +457,7 @@ def ground_plane_model(x, y, tile_size, name, material): file://materials/textures {material} + 1 1 1 1 0 diff --git a/commonroad/renderer/models/Ramp.fcstd b/commonroad/renderer/models/Ramp.fcstd new file mode 100755 index 0000000..d07ff78 Binary files /dev/null and b/commonroad/renderer/models/Ramp.fcstd differ diff --git a/commonroad/renderer/models/Ramp.fcstd1 b/commonroad/renderer/models/Ramp.fcstd1 new file mode 100755 index 0000000..407687a Binary files /dev/null and b/commonroad/renderer/models/Ramp.fcstd1 differ diff --git a/commonroad/renderer/models/__init__.py b/commonroad/renderer/models/__init__.py old mode 100644 new mode 100755 diff --git a/commonroad/renderer/models/car-cc2017.dae b/commonroad/renderer/models/car-cc2017.dae old mode 100644 new mode 100755 diff --git a/commonroad/renderer/models/ramp.dae b/commonroad/renderer/models/ramp.dae new file mode 100755 index 0000000..a05a242 --- /dev/null +++ b/commonroad/renderer/models/ramp.dae @@ -0,0 +1,106 @@ + + + + 2019-01-04T18:58:53.051446 + 2019-01-04T18:58:53.051471 + + Z_UP + + + + + + + + 0.0 0.0 0.0 1.0 + + + 0.0 0.0 0.0 1.0 + + + 0.800000011921 0.800000011921 0.800000011921 1.0 + + + 1 1 1 1.0 + + + 0.0 + + + 0.0 0.0 0.0 1.0 + + + 0.0 + + + 0.0 0.0 0.0 1.0 + + + 1.0 + + + + + + 0 + + + + + + + + + + -0.1736482 0.9848077 0 -0.1736482 0.9848077 0 0 -1 0 0 -1 0 1.717683e-17 1 0 1.717683e-17 1 -0 -0.1736482 0.9848077 0 -0.1736482 0.9848077 0 0 0 -1 0 0 -1 0 0 -1 0 0 -1 0.1736482 0.9848077 0 0.1736482 0.9848077 -0 -0 -1 0 0 -1 -0 0 -1 0 0 -1 0 1.717683e-17 1 0 1.717683e-17 1 0 0 0 1 0 0 1 0 0 1 0 0 1 -1 0 0 -1 -0 0 0 1 -0 0 1 0 1 0 0 1 -0 0 0.1736482 0.9848077 0 0.1736482 0.9848077 0 -0 -1 0 0 -1 -0 0 0 1 0 0 1 -1 0 0 -1 0 0 -0 1 0 0 1 0 1 0 0 1 0 0 0 0 -1 0 0 -1 + + + + + + + + + + 0 4e-18 0.1 -0.2835641 -0.05 -0.1 -0.2835641 -0.05 0.1 0 4e-18 -0.1 0.5164359 -0.05 -0.1 0.5164359 -0.05 0.1 0.2328718 0 -0.1 0.2328718 0 0.1 -0.2835641 -0.05 -0.3 0 4e-18 -0.3 -0.2835641 0.05 0.1 0.5164359 0.05 0.1 0.5164359 -0.05 -0.3 -0.2835641 -0.05 0.12 0.5164359 -0.05 0.12 0.2328718 0 -0.3 -0.2835641 0.05 -0.3 0.5164359 0.05 -0.3 -0.2835641 0.05 0.12 0.5164359 0.05 0.12 -0.2835641 -0.05 -0.32 0.5164359 -0.05 -0.32 -0.2835641 0.05 -0.32 0.5164359 0.05 -0.32 + + + + + + + + + + + + + + +

0 0 1 0 2 0 3 1 1 1 0 1 1 2 4 2 2 2 2 3 4 3 5 3 6 4 3 4 0 4 6 5 0 5 7 5 1 6 3 6 8 6 8 7 3 7 9 7 10 8 0 8 2 8 7 9 11 9 5 9 10 10 11 10 0 10 0 11 11 11 7 11 5 12 6 12 7 12 4 13 6 13 5 13 4 14 1 14 8 14 4 15 8 15 12 15 2 16 5 16 13 16 13 17 5 17 14 17 3 18 6 18 9 18 9 19 6 19 15 19 9 20 16 20 8 20 17 21 15 21 12 21 17 22 16 22 9 22 17 23 9 23 15 23 10 24 2 24 18 24 18 25 2 25 13 25 11 26 10 26 19 26 19 27 10 27 18 27 5 28 11 28 14 28 14 29 11 29 19 29 6 30 12 30 15 30 6 31 4 31 12 31 12 32 8 32 20 32 12 33 20 33 21 33 14 34 18 34 13 34 19 35 18 35 14 35 20 36 16 36 22 36 8 37 16 37 20 37 16 38 17 38 23 38 16 39 23 39 22 39 23 40 12 40 21 40 17 41 12 41 23 41 22 42 21 42 20 42 22 43 23 43 21 43

+ + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/commonroad/renderer/obstacle.py b/commonroad/renderer/obstacle.py old mode 100644 new mode 100755 diff --git a/commonroad/renderer/sdf.py b/commonroad/renderer/sdf.py old mode 100644 new mode 100755 index 8f640ae..de2edb0 --- a/commonroad/renderer/sdf.py +++ b/commonroad/renderer/sdf.py @@ -1,21 +1,31 @@ -from commonroad.renderer import groundplane, obstacle, traffic_sign, ego_vehicle +from commonroad.renderer import groundplane, obstacle, traffic_sign, ego_vehicle, special_objects +# we assume that the road width config set here is the same used during the generation +from commonroad.generator import road_generation from commonroad import schema -from os import path +from os import path, makedirs -def generate_sdf(xml_content, target_dir): +def generate_sdf(xml_content, target_dir, add_vehicle): doc = schema.CreateFromDocument(xml_content) content = groundplane.draw(doc, target_dir) - content += ego_vehicle.draw(target_dir, doc.lanelet) + if add_vehicle: + content += ego_vehicle.draw(target_dir, doc.lanelet) for obst in doc.obstacle: - if obst.type != "blockedArea": + if obst.type != "blockedArea" and obst.type != "segmentationIntersection": content += obstacle.draw(obst) for sign in doc.trafficSign: content += traffic_sign.draw(sign, target_dir) + for ramp in doc.ramp: + content += special_objects.draw_ramp(ramp.centerPoint.x, ramp.centerPoint.y, ramp.orientation, ramp.id) - with open(path.join(target_dir, "world.sdf"), "w") as file: + if not path.exists(path.join(target_dir, "worlds")): + makedirs(path.join(target_dir, "worlds")) + + with open(path.join(target_dir, "worlds", "world.sdf"), "w+") as file: file.write("") file.write(sun_light()) + file.write(spot_light(pose=[0, 0, 0.2, 0, 0, 0], idx=0)) + file.write(sky()) file.write(content) file.write("") @@ -35,3 +45,61 @@ def sun_light(): 1 """ + +def spot_light(pose, idx): + return """ + + true + {x} {y} {z} {r} {p} {yaw} + 1.0 1.0 1.0 1 + 1.0 1.0 1.0 1 + 0.1 0.1 -0.9 + + 20 + 0.5 + 0.01 + 0.001 + + + 0.4 + 1.0 + 3.0 + + + """.format(idx=idx, x=pose[0], y=pose[1], z=pose[2], r=pose[3], p=pose[4], yaw=pose[4]) + +def sky(): + return """ + +0.5 0.5 0.5 0.5 + + + + 0 0 0 0 + + +false +10. +none +false + + + """ + # return """ + # + # + # + # + # 0 0 0 0 + # + # + # + # """ \ No newline at end of file diff --git a/commonroad/renderer/signs/10_zone_beginn.png b/commonroad/renderer/signs/10_zone_beginn.png new file mode 100755 index 0000000..8db37f1 Binary files /dev/null and b/commonroad/renderer/signs/10_zone_beginn.png differ diff --git a/commonroad/renderer/signs/20_zone_beginn.png b/commonroad/renderer/signs/20_zone_beginn.png new file mode 100755 index 0000000..49ce12c Binary files /dev/null and b/commonroad/renderer/signs/20_zone_beginn.png differ diff --git a/commonroad/renderer/signs/40_zone_beginn.png b/commonroad/renderer/signs/40_zone_beginn.png new file mode 100755 index 0000000..5565f53 Binary files /dev/null and b/commonroad/renderer/signs/40_zone_beginn.png differ diff --git a/commonroad/renderer/signs/50_zone_beginn.png b/commonroad/renderer/signs/50_zone_beginn.png new file mode 100755 index 0000000..6441e2c Binary files /dev/null and b/commonroad/renderer/signs/50_zone_beginn.png differ diff --git a/commonroad/renderer/signs/60_zone_beginn.png b/commonroad/renderer/signs/60_zone_beginn.png new file mode 100755 index 0000000..dbf1424 Binary files /dev/null and b/commonroad/renderer/signs/60_zone_beginn.png differ diff --git a/commonroad/renderer/signs/70_zone_beginn.png b/commonroad/renderer/signs/70_zone_beginn.png new file mode 100755 index 0000000..5ace3d6 Binary files /dev/null and b/commonroad/renderer/signs/70_zone_beginn.png differ diff --git a/commonroad/renderer/signs/80_zone_beginn.png b/commonroad/renderer/signs/80_zone_beginn.png new file mode 100755 index 0000000..7cb38b6 Binary files /dev/null and b/commonroad/renderer/signs/80_zone_beginn.png differ diff --git a/commonroad/renderer/signs/90_zone_beginn.png b/commonroad/renderer/signs/90_zone_beginn.png new file mode 100755 index 0000000..958070c Binary files /dev/null and b/commonroad/renderer/signs/90_zone_beginn.png differ diff --git a/commonroad/renderer/signs/__init__.py b/commonroad/renderer/signs/__init__.py old mode 100644 new mode 100755 diff --git a/commonroad/renderer/signs/ende_10_zone.png b/commonroad/renderer/signs/ende_10_zone.png new file mode 100755 index 0000000..9f4f5ae Binary files /dev/null and b/commonroad/renderer/signs/ende_10_zone.png differ diff --git a/commonroad/renderer/signs/ende_20_zone.png b/commonroad/renderer/signs/ende_20_zone.png new file mode 100755 index 0000000..ba2a8a7 Binary files /dev/null and b/commonroad/renderer/signs/ende_20_zone.png differ diff --git a/commonroad/renderer/signs/ende_40_zone.png b/commonroad/renderer/signs/ende_40_zone.png new file mode 100755 index 0000000..68169b5 Binary files /dev/null and b/commonroad/renderer/signs/ende_40_zone.png differ diff --git a/commonroad/renderer/signs/ende_50_zone.png b/commonroad/renderer/signs/ende_50_zone.png new file mode 100755 index 0000000..de302b9 Binary files /dev/null and b/commonroad/renderer/signs/ende_50_zone.png differ diff --git a/commonroad/renderer/signs/ende_60_zone.png b/commonroad/renderer/signs/ende_60_zone.png new file mode 100755 index 0000000..6b94d5d Binary files /dev/null and b/commonroad/renderer/signs/ende_60_zone.png differ diff --git a/commonroad/renderer/signs/ende_70_zone.png b/commonroad/renderer/signs/ende_70_zone.png new file mode 100755 index 0000000..a8fee53 Binary files /dev/null and b/commonroad/renderer/signs/ende_70_zone.png differ diff --git a/commonroad/renderer/signs/ende_80_zone.png b/commonroad/renderer/signs/ende_80_zone.png new file mode 100755 index 0000000..bb3e107 Binary files /dev/null and b/commonroad/renderer/signs/ende_80_zone.png differ diff --git a/commonroad/renderer/signs/ende_90_zone.png b/commonroad/renderer/signs/ende_90_zone.png new file mode 100755 index 0000000..f6e5ef8 Binary files /dev/null and b/commonroad/renderer/signs/ende_90_zone.png differ diff --git a/commonroad/renderer/signs/stvo-108-10.png b/commonroad/renderer/signs/stvo-108-10.png new file mode 100755 index 0000000..0ee95cf Binary files /dev/null and b/commonroad/renderer/signs/stvo-108-10.png differ diff --git a/commonroad/renderer/signs/stvo-110-10.png b/commonroad/renderer/signs/stvo-110-10.png new file mode 100755 index 0000000..772fc72 Binary files /dev/null and b/commonroad/renderer/signs/stvo-110-10.png differ diff --git a/commonroad/renderer/signs/stvo-205.png b/commonroad/renderer/signs/stvo-205.png old mode 100644 new mode 100755 diff --git a/commonroad/renderer/signs/stvo-206.png b/commonroad/renderer/signs/stvo-206.png old mode 100644 new mode 100755 diff --git a/commonroad/renderer/signs/stvo-208.png b/commonroad/renderer/signs/stvo-208.png old mode 100644 new mode 100755 diff --git a/commonroad/renderer/signs/stvo-209-10.png b/commonroad/renderer/signs/stvo-209-10.png old mode 100644 new mode 100755 diff --git a/commonroad/renderer/signs/stvo-209-20.png b/commonroad/renderer/signs/stvo-209-20.png old mode 100644 new mode 100755 diff --git a/commonroad/renderer/signs/stvo-222.png b/commonroad/renderer/signs/stvo-222.png new file mode 100755 index 0000000..5c8e693 Binary files /dev/null and b/commonroad/renderer/signs/stvo-222.png differ diff --git a/commonroad/renderer/signs/stvo-274.1.png b/commonroad/renderer/signs/stvo-274.1.png old mode 100644 new mode 100755 diff --git a/commonroad/renderer/signs/stvo-274.2.png b/commonroad/renderer/signs/stvo-274.2.png old mode 100644 new mode 100755 diff --git a/commonroad/renderer/signs/stvo-276.png b/commonroad/renderer/signs/stvo-276.png old mode 100644 new mode 100755 diff --git a/commonroad/renderer/signs/stvo-280.png b/commonroad/renderer/signs/stvo-280.png old mode 100644 new mode 100755 diff --git a/commonroad/renderer/signs/stvo-306.png b/commonroad/renderer/signs/stvo-306.png old mode 100644 new mode 100755 diff --git a/commonroad/renderer/signs/stvo-314.png b/commonroad/renderer/signs/stvo-314.png new file mode 100755 index 0000000..325e01d Binary files /dev/null and b/commonroad/renderer/signs/stvo-314.png differ diff --git a/commonroad/renderer/signs/stvo-331.1.png b/commonroad/renderer/signs/stvo-331.1.png new file mode 100755 index 0000000..0fb159b Binary files /dev/null and b/commonroad/renderer/signs/stvo-331.1.png differ diff --git a/commonroad/renderer/signs/stvo-331.2.png b/commonroad/renderer/signs/stvo-331.2.png new file mode 100755 index 0000000..7b28027 Binary files /dev/null and b/commonroad/renderer/signs/stvo-331.2.png differ diff --git a/commonroad/renderer/signs/stvo-350-10.png b/commonroad/renderer/signs/stvo-350-10.png old mode 100644 new mode 100755 diff --git a/commonroad/renderer/signs/stvo-625-10.png b/commonroad/renderer/signs/stvo-625-10.png old mode 100644 new mode 100755 diff --git a/commonroad/renderer/signs/stvo-625-11.png b/commonroad/renderer/signs/stvo-625-11.png old mode 100644 new mode 100755 diff --git a/commonroad/renderer/signs/stvo-625-20.png b/commonroad/renderer/signs/stvo-625-20.png old mode 100644 new mode 100755 diff --git a/commonroad/renderer/signs/stvo-625-21.png b/commonroad/renderer/signs/stvo-625-21.png old mode 100644 new mode 100755 diff --git a/commonroad/renderer/special_objects.py b/commonroad/renderer/special_objects.py new file mode 100755 index 0000000..a5e2ebb --- /dev/null +++ b/commonroad/renderer/special_objects.py @@ -0,0 +1,27 @@ +def draw_ramp(x, y, orientation, name): + return """ + + + + 1 + + + file://meshes/Ramp.dae + 0.001 0.001 0.001 + + + + + + + file://meshes/Ramp.dae + 0.001 0.001 0.001 + + + + 0 + + {x} {y} {z} 0 0 {orientation} + true + + """.format(x=x, y=y, z=0.0, orientation=orientation, name=name) \ No newline at end of file diff --git a/commonroad/renderer/street_markings/Fahrbahnmarkierung_Pfeil_L.svg b/commonroad/renderer/street_markings/Fahrbahnmarkierung_Pfeil_L.svg new file mode 100644 index 0000000..580c609 --- /dev/null +++ b/commonroad/renderer/street_markings/Fahrbahnmarkierung_Pfeil_L.svg @@ -0,0 +1,35 @@ + + + + + + image/svg+xml + + + + + + + + + + diff --git a/commonroad/renderer/street_markings/Fahrbahnmarkierung_Pfeil_L_inkscape.svg b/commonroad/renderer/street_markings/Fahrbahnmarkierung_Pfeil_L_inkscape.svg new file mode 100644 index 0000000..1335c59 --- /dev/null +++ b/commonroad/renderer/street_markings/Fahrbahnmarkierung_Pfeil_L_inkscape.svg @@ -0,0 +1,65 @@ + + + + + + image/svg+xml + + + + + + + + + + + diff --git a/commonroad/renderer/street_markings/Fahrbahnmarkierung_Pfeil_R.svg b/commonroad/renderer/street_markings/Fahrbahnmarkierung_Pfeil_R.svg new file mode 100644 index 0000000..0554e7e --- /dev/null +++ b/commonroad/renderer/street_markings/Fahrbahnmarkierung_Pfeil_R.svg @@ -0,0 +1,35 @@ + + + + + + image/svg+xml + + + + + + + + + + diff --git a/commonroad/renderer/street_markings/Fahrbahnmarkierung_Pfeil_R_inkscape.svg b/commonroad/renderer/street_markings/Fahrbahnmarkierung_Pfeil_R_inkscape.svg new file mode 100644 index 0000000..05047e8 --- /dev/null +++ b/commonroad/renderer/street_markings/Fahrbahnmarkierung_Pfeil_R_inkscape.svg @@ -0,0 +1,68 @@ + + + + + + image/svg+xml + + + + + + + + + + + + + diff --git a/commonroad/renderer/traffic_sign.py b/commonroad/renderer/traffic_sign.py old mode 100644 new mode 100755 index 0740dc5..89d7bb4 --- a/commonroad/renderer/traffic_sign.py +++ b/commonroad/renderer/traffic_sign.py @@ -1,83 +1,102 @@ -import os, shutil, pkg_resources, math -from os import path - -ALL_SIZES = { - "stvo-274.1": {"w": 0.15, "h": 0.15}, # zone 30 (begin) - "stvo-274.2": {"w": 0.15, "h": 0.15}, # zone 30 (end) - "stvo-350-10": {"w": 0.15, "h": 0.15}, # zebra crossing - "stvo-625-11": {"w": 0.3, "h": 0.1}, # large curve sign (left) - "stvo-625-21": {"w": 0.3, "h": 0.1} # large curve sign (right) +SIGN_MESHES = { + "10_zone_beginn": {"mesh": "10zone_start", "collision_box_size": "0.11 0.15 0.29", + "collision_box_pose": "-0.055 0 0.145 0 0 0"}, + "20_zone_beginn": {"mesh": "20zone_start", "collision_box_size": "0.11 0.15 0.29", + "collision_box_pose": "-0.055 0 0.145 0 0 0"}, + "40_zone_beginn": {"mesh": "40zone_start", "collision_box_size": "0.11 0.15 0.29", + "collision_box_pose": "-0.055 0 0.145 0 0 0"}, + "50_zone_beginn": {"mesh": "50zone_start", "collision_box_size": "0.11 0.15 0.29", + "collision_box_pose": "-0.055 0 0.145 0 0 0"}, + "60_zone_beginn": {"mesh": "60zone_start", "collision_box_size": "0.11 0.15 0.29", + "collision_box_pose": "-0.055 0 0.145 0 0 0"}, + "70_zone_beginn": {"mesh": "70zone_start", "collision_box_size": "0.11 0.15 0.29", + "collision_box_pose": "-0.055 0 0.145 0 0 0"}, + "80_zone_beginn": {"mesh": "80zone_start", "collision_box_size": "0.11 0.15 0.29", + "collision_box_pose": "-0.055 0 0.145 0 0 0"}, + "90_zone_beginn": {"mesh": "90zone_start", "collision_box_size": "0.11 0.15 0.29", + "collision_box_pose": "-0.055 0 0.145 0 0 0"}, + "ende_10_zone": {"mesh": "10zone_end", "collision_box_size": "0.11 0.15 0.29", + "collision_box_pose": "-0.055 0 0.145 0 0 0"}, + "ende_20_zone": {"mesh": "20zone_end", "collision_box_size": "0.11 0.15 0.29", + "collision_box_pose": "-0.055 0 0.145 0 0 0"}, + "ende_40_zone": {"mesh": "40zone_end", "collision_box_size": "0.11 0.15 0.29", + "collision_box_pose": "-0.055 0 0.145 0 0 0"}, + "ende_50_zone": {"mesh": "50zone_end", "collision_box_size": "0.11 0.15 0.29", + "collision_box_pose": "-0.055 0 0.145 0 0 0"}, + "ende_60_zone": {"mesh": "60zone_end", "collision_box_size": "0.11 0.15 0.29", + "collision_box_pose": "-0.055 0 0.145 0 0 0"}, + "ende_70_zone": {"mesh": "70zone_end", "collision_box_size": "0.11 0.15 0.29", + "collision_box_pose": "-0.055 0 0.145 0 0 0"}, + "ende_80_zone": {"mesh": "80zone_end", "collision_box_size": "0.11 0.15 0.29", + "collision_box_pose": "-0.055 0 0.145 0 0 0"}, + "ende_90_zone": {"mesh": "90zone_end", "collision_box_size": "0.11 0.15 0.29", + "collision_box_pose": "-0.055 0 0.145 0 0 0"}, + "stvo-108-10": {"mesh": "Steigung_Ende", "collision_box_size": "0.11 0.15 0.29", + "collision_box_pose": "-0.055 0 0.145 0 0 0"}, # gefaelle 10 (ende) + "stvo-110-10": {"mesh": "Steigung_Start", "collision_box_size": "0.11 0.15 0.29", + "collision_box_pose": "-0.055 0 0.145 0 0 0"}, # steigung 10 (begin) + "stvo-205": {"mesh": "VorfahrtGewaehren", "collision_box_size": "0.11 0.15 0.29", + "collision_box_pose": "-0.055 0 0.145 0 0 0"}, # vorfahrt gewaehren + "stvo-206": {"mesh": "Stopschild", "collision_box_size": "0.11 0.15 0.29", + "collision_box_pose": "-0.055 0 0.145 0 0 0"}, # stop + "stvo-208": {"mesh": "Barred_area", "collision_box_size": "0.11 0.15 0.29", + "collision_box_pose": "-0.055 0 0.145 0 0 0"}, # gegenverkehr vorrang (begin) + "stvo-209-10": {"mesh": "Links_abbiegen", "collision_box_size": "0.11 0.15 0.29", + "collision_box_pose": "-0.055 0 0.145 0 0 0"}, # turn left + "stvo-209-20": {"mesh": "Rechts_abbiegen", "collision_box_size": "0.11 0.15 0.29", + "collision_box_pose": "-0.055 0 0.145 0 0 0"}, # turn right + "stvo-222": {"mesh": "VorbeifahrtRechts_pedestrian", "collision_box_size": "0.11 0.15 0.15", + "collision_box_pose": "-0.055 0 0.075 0 0 0"}, # rechts vorbeifahren (on pedestrian island) + "stvo-274.1": {"mesh": "30zone_start", "collision_box_size": "0.11 0.15 0.29", + "collision_box_pose": "-0.055 0 0.145 0 0 0"}, # zone 30 (begin) + "stvo-274.2": {"mesh": "30zone_end", "collision_box_size": "0.11 0.15 0.29", + "collision_box_pose": "-0.055 0 0.145 0 0 0"}, # zone 30 (end) + "stvo-306": {"mesh": "Vorfahrt", "collision_box_size": "0.11 0.15 0.29", + "collision_box_pose": "-0.055 0 0.145 0 0 0"}, # vorfahrtstrasse + "stvo-350-10": {"mesh": "PedestrianCrossing", "collision_box_size": "0.11 0.15 0.29", + "collision_box_pose": "-0.055 0 0.145 0 0 0"}, # zebra crossing + "stvo-625-10": {"mesh": "Abbiegeschild_links", "collision_box_size": "0.09 0.1 0.11", + "collision_box_pose": "-0.045 0 0.055 0 0 0"}, # small curve sign (left) + "stvo-625-11": {"mesh": "Abbiegeschild_gross_links", "collision_box_size": "0.09 0.3 0.11", + "collision_box_pose": "-0.045 0 0.055 0 0 0"}, # large curve sign (left) + "stvo-625-20": {"mesh": "Abbiegeschild_rechts", "collision_box_size": "0.09 0.1 0.11", + "collision_box_pose": "-0.045 0 0.055 0 0 0"}, # small curve sign (right) + "stvo-625-21": {"mesh": "Abbiegeschild_gross_links", "collision_box_size": "0.09 0.3 0.11", + "collision_box_pose": "-0.045 0 0.055 0 0 0"} # large curve sign (right) } -DEFAULT_SIZE = {"w": 0.1, "h": 0.1} -HEIGHT = 0.15 - -def draw(sign, target_dir): - os.makedirs(path.join(target_dir, "materials", "textures"), exist_ok=True) - os.makedirs(path.join(target_dir, "materials", "scripts"), exist_ok=True) - - texture_file = "sign-{0}.png".format(sign.type) - material_file = "sign-{0}.material".format(sign.type) - - texture_stream = pkg_resources.resource_stream("commonroad.renderer.signs", - "{0}.png".format(sign.type)) - with open(path.join(target_dir, "materials", "textures", texture_file), "wb") as texture_target: - shutil.copyfileobj(texture_stream, texture_target) - with open(path.join(target_dir, "materials", "scripts", material_file), "w") as material_target: - material_target.write(material("Sign/{0}".format(sign.type), texture_file)) - size = ALL_SIZES.get(sign.type, DEFAULT_SIZE) - - return model(sign.centerPoint.x, sign.centerPoint.y, HEIGHT + size["h"]/2, sign.orientation + math.pi/2, - "Sign/{0}".format(sign.id), "Sign/{0}".format(sign.type), size["w"], size["h"]) - -def material(name, file): - return """ - material {name} - {{ - technique - {{ - pass - {{ - scene_blend alpha_blend - depth_write off +def draw(sign, target_dir): + return model(sign.centerPoint.x, sign.centerPoint.y, 0.0, sign.orientation, + "Sign/{0}".format(sign.id), SIGN_MESHES[sign.type]["mesh"], + SIGN_MESHES[sign.type]["collision_box_pose"], + SIGN_MESHES[sign.type]["collision_box_size"]) - texture_unit - {{ - texture {file} - filtering trilinear - }} - }} - }} - }} - """.format(name=name, file=file) -def model(x, y, z, orientation, name, material, width, height): +def model(x, y, z, orientation, name, mesh, collision_box_pose, collision_box_size): return """ - - 1 + - 0 + 1 - - 0 0 1 - {width} {height} - + + file://meshes/{mesh}.dae + 0.001 0.001 0.001 + - - - + + {collision_box_pose} + + + {collision_box_size} + + + 0 - 0 - 0 {x} {y} {z} {angle} 0 {orientation} """.format(x=x, y=y, z=z, orientation=orientation, name=name, - material=material, width=width, height=height, angle=math.pi/2) + mesh=mesh, angle=0, collision_box_pose=collision_box_pose, collision_box_size=collision_box_size) diff --git a/commonroad/schema-extended.xsd b/commonroad/schema-extended.xsd new file mode 100755 index 0000000..6ef0cfd --- /dev/null +++ b/commonroad/schema-extended.xsd @@ -0,0 +1,477 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/commonroad/schema.py b/commonroad/schema.py index f139e57..78769be 100644 --- a/commonroad/schema.py +++ b/commonroad/schema.py @@ -1,7 +1,7 @@ -# ./commonroad/schema.py +# ./schema.py # -*- coding: utf-8 -*- # PyXB bindings for NM:e92452c8d3e28a9e27abfc9994d2007779e7f4c9 -# Generated 2017-04-26 14:38:36.537036 by PyXB version 1.2.5 using Python 3.5.2.final.0 +# Generated 2019-11-24 12:46:45.851979 by PyXB version 1.2.6 using Python 3.6.8.final.0 # Namespace AbsentNamespace0 from __future__ import unicode_literals @@ -14,10 +14,10 @@ import sys import pyxb.utils.six as _six # Unique identifier for bindings created at the same time -_GenerationUID = pyxb.utils.utility.UniqueIdentifier('urn:uuid:445dad52-2a7d-11e7-bed2-6d781d4ce578') +_GenerationUID = pyxb.utils.utility.UniqueIdentifier('urn:uuid:1764c064-0eb0-11ea-aff7-14abc508d135') # Version of PyXB used to generate the bindings -_PyXBVersion = '1.2.5' +_PyXBVersion = '1.2.6' # Generated bindings are not compatible across PyXB versions if pyxb.__version__ != _PyXBVersion: raise pyxb.PyXBVersionError(_PyXBVersion) @@ -82,9 +82,9 @@ class distance (pyxb.binding.datatypes.float): """An atomic simple type.""" _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'distance') - _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 4, 4) + _XSDLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 4, 4) _Documentation = None -distance._CF_minExclusive = pyxb.binding.facets.CF_minExclusive(value=pyxb.binding.datatypes._fp(0.0), value_datatype=pyxb.binding.datatypes.float) +distance._CF_minExclusive = pyxb.binding.facets.CF_minExclusive(value_datatype=pyxb.binding.datatypes.float, value=pyxb.binding.datatypes._fp(0.0)) distance._InitializeFacetMap(distance._CF_minExclusive) Namespace.addCategoryObject('typeBinding', 'distance', distance) _module_typeBindings.distance = distance @@ -95,9 +95,9 @@ class obstacleRole (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeratio """An atomic simple type.""" _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'obstacleRole') - _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 153, 4) + _XSDLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 153, 4) _Documentation = None -obstacleRole._CF_enumeration = pyxb.binding.facets.CF_enumeration(enum_prefix=None, value_datatype=obstacleRole) +obstacleRole._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=obstacleRole, enum_prefix=None) obstacleRole.static = obstacleRole._CF_enumeration.addEnumeration(unicode_value='static', tag='static') obstacleRole.dynamic = obstacleRole._CF_enumeration.addEnumeration(unicode_value='dynamic', tag='dynamic') obstacleRole._InitializeFacetMap(obstacleRole._CF_enumeration) @@ -110,9 +110,9 @@ class obstacleType (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeratio """An atomic simple type.""" _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'obstacleType') - _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 160, 4) + _XSDLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 160, 4) _Documentation = None -obstacleType._CF_enumeration = pyxb.binding.facets.CF_enumeration(enum_prefix=None, value_datatype=obstacleType) +obstacleType._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=obstacleType, enum_prefix=None) obstacleType.unknown = obstacleType._CF_enumeration.addEnumeration(unicode_value='unknown', tag='unknown') obstacleType.parkedVehicle = obstacleType._CF_enumeration.addEnumeration(unicode_value='parkedVehicle', tag='parkedVehicle') obstacleType.constructionZone = obstacleType._CF_enumeration.addEnumeration(unicode_value='constructionZone', tag='constructionZone') @@ -123,6 +123,7 @@ class obstacleType (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeratio obstacleType.bicycle = obstacleType._CF_enumeration.addEnumeration(unicode_value='bicycle', tag='bicycle') obstacleType.pedestrian = obstacleType._CF_enumeration.addEnumeration(unicode_value='pedestrian', tag='pedestrian') obstacleType.priorityVehicle = obstacleType._CF_enumeration.addEnumeration(unicode_value='priorityVehicle', tag='priorityVehicle') +obstacleType.segmentationIntersection = obstacleType._CF_enumeration.addEnumeration(unicode_value='segmentationIntersection', tag='segmentationIntersection') obstacleType.blockedArea = obstacleType._CF_enumeration.addEnumeration(unicode_value='blockedArea', tag='blockedArea') obstacleType._InitializeFacetMap(obstacleType._CF_enumeration) Namespace.addCategoryObject('typeBinding', 'obstacleType', obstacleType) @@ -134,9 +135,9 @@ class lineMarking (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration """An atomic simple type.""" _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'lineMarking') - _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 206, 4) + _XSDLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 207, 4) _Documentation = None -lineMarking._CF_enumeration = pyxb.binding.facets.CF_enumeration(enum_prefix=None, value_datatype=lineMarking) +lineMarking._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=lineMarking, enum_prefix=None) lineMarking.dashed = lineMarking._CF_enumeration.addEnumeration(unicode_value='dashed', tag='dashed') lineMarking.solid = lineMarking._CF_enumeration.addEnumeration(unicode_value='solid', tag='solid') lineMarking._InitializeFacetMap(lineMarking._CF_enumeration) @@ -149,9 +150,9 @@ class drivingDir (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_ """An atomic simple type.""" _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'drivingDir') - _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 234, 4) + _XSDLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 244, 4) _Documentation = None -drivingDir._CF_enumeration = pyxb.binding.facets.CF_enumeration(enum_prefix=None, value_datatype=drivingDir) +drivingDir._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=drivingDir, enum_prefix=None) drivingDir.same = drivingDir._CF_enumeration.addEnumeration(unicode_value='same', tag='same') drivingDir.opposite = drivingDir._CF_enumeration.addEnumeration(unicode_value='opposite', tag='opposite') drivingDir._InitializeFacetMap(drivingDir._CF_enumeration) @@ -164,9 +165,9 @@ class laneletType (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration """An atomic simple type.""" _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'laneletType') - _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 247, 4) + _XSDLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 257, 4) _Documentation = None -laneletType._CF_enumeration = pyxb.binding.facets.CF_enumeration(enum_prefix=None, value_datatype=laneletType) +laneletType._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=laneletType, enum_prefix=None) laneletType.road = laneletType._CF_enumeration.addEnumeration(unicode_value='road', tag='road') laneletType.sidewalk = laneletType._CF_enumeration.addEnumeration(unicode_value='sidewalk', tag='sidewalk') laneletType.zebraCrossing = laneletType._CF_enumeration.addEnumeration(unicode_value='zebraCrossing', tag='zebraCrossing') @@ -174,23 +175,78 @@ class laneletType (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration Namespace.addCategoryObject('typeBinding', 'laneletType', laneletType) _module_typeBindings.laneletType = laneletType +# Atomic simple type: roadMarkingType +class roadMarkingType (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin): + + """An atomic simple type.""" + + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'roadMarkingType') + _XSDLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 317, 4) + _Documentation = None +roadMarkingType._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=roadMarkingType, enum_prefix=None) +roadMarkingType.n10_zone_beginn = roadMarkingType._CF_enumeration.addEnumeration(unicode_value='10_zone_beginn', tag='n10_zone_beginn') +roadMarkingType.n20_zone_beginn = roadMarkingType._CF_enumeration.addEnumeration(unicode_value='20_zone_beginn', tag='n20_zone_beginn') +roadMarkingType.n40_zone_beginn = roadMarkingType._CF_enumeration.addEnumeration(unicode_value='40_zone_beginn', tag='n40_zone_beginn') +roadMarkingType.n50_zone_beginn = roadMarkingType._CF_enumeration.addEnumeration(unicode_value='50_zone_beginn', tag='n50_zone_beginn') +roadMarkingType.n60_zone_beginn = roadMarkingType._CF_enumeration.addEnumeration(unicode_value='60_zone_beginn', tag='n60_zone_beginn') +roadMarkingType.n70_zone_beginn = roadMarkingType._CF_enumeration.addEnumeration(unicode_value='70_zone_beginn', tag='n70_zone_beginn') +roadMarkingType.n80_zone_beginn = roadMarkingType._CF_enumeration.addEnumeration(unicode_value='80_zone_beginn', tag='n80_zone_beginn') +roadMarkingType.n90_zone_beginn = roadMarkingType._CF_enumeration.addEnumeration(unicode_value='90_zone_beginn', tag='n90_zone_beginn') +roadMarkingType.ende_10_zone = roadMarkingType._CF_enumeration.addEnumeration(unicode_value='ende_10_zone', tag='ende_10_zone') +roadMarkingType.ende_20_zone = roadMarkingType._CF_enumeration.addEnumeration(unicode_value='ende_20_zone', tag='ende_20_zone') +roadMarkingType.ende_40_zone = roadMarkingType._CF_enumeration.addEnumeration(unicode_value='ende_40_zone', tag='ende_40_zone') +roadMarkingType.ende_50_zone = roadMarkingType._CF_enumeration.addEnumeration(unicode_value='ende_50_zone', tag='ende_50_zone') +roadMarkingType.ende_60_zone = roadMarkingType._CF_enumeration.addEnumeration(unicode_value='ende_60_zone', tag='ende_60_zone') +roadMarkingType.ende_70_zone = roadMarkingType._CF_enumeration.addEnumeration(unicode_value='ende_70_zone', tag='ende_70_zone') +roadMarkingType.ende_80_zone = roadMarkingType._CF_enumeration.addEnumeration(unicode_value='ende_80_zone', tag='ende_80_zone') +roadMarkingType.ende_90_zone = roadMarkingType._CF_enumeration.addEnumeration(unicode_value='ende_90_zone', tag='ende_90_zone') +roadMarkingType.stvo_274_1 = roadMarkingType._CF_enumeration.addEnumeration(unicode_value='stvo-274.1', tag='stvo_274_1') +roadMarkingType.stvo_274_2 = roadMarkingType._CF_enumeration.addEnumeration(unicode_value='stvo-274.2', tag='stvo_274_2') +roadMarkingType.turn_left = roadMarkingType._CF_enumeration.addEnumeration(unicode_value='turn_left', tag='turn_left') +roadMarkingType.turn_right = roadMarkingType._CF_enumeration.addEnumeration(unicode_value='turn_right', tag='turn_right') +roadMarkingType._InitializeFacetMap(roadMarkingType._CF_enumeration) +Namespace.addCategoryObject('typeBinding', 'roadMarkingType', roadMarkingType) +_module_typeBindings.roadMarkingType = roadMarkingType + # Atomic simple type: [anonymous] class STD_ANON (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin): """An atomic simple type.""" _ExpandedName = None - _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 304, 16) + _XSDLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 355, 16) _Documentation = None -STD_ANON._CF_enumeration = pyxb.binding.facets.CF_enumeration(enum_prefix=None, value_datatype=STD_ANON) +STD_ANON._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON, enum_prefix=None) +STD_ANON.n10_zone_beginn = STD_ANON._CF_enumeration.addEnumeration(unicode_value='10_zone_beginn', tag='n10_zone_beginn') +STD_ANON.n20_zone_beginn = STD_ANON._CF_enumeration.addEnumeration(unicode_value='20_zone_beginn', tag='n20_zone_beginn') +STD_ANON.n40_zone_beginn = STD_ANON._CF_enumeration.addEnumeration(unicode_value='40_zone_beginn', tag='n40_zone_beginn') +STD_ANON.n50_zone_beginn = STD_ANON._CF_enumeration.addEnumeration(unicode_value='50_zone_beginn', tag='n50_zone_beginn') +STD_ANON.n60_zone_beginn = STD_ANON._CF_enumeration.addEnumeration(unicode_value='60_zone_beginn', tag='n60_zone_beginn') +STD_ANON.n70_zone_beginn = STD_ANON._CF_enumeration.addEnumeration(unicode_value='70_zone_beginn', tag='n70_zone_beginn') +STD_ANON.n80_zone_beginn = STD_ANON._CF_enumeration.addEnumeration(unicode_value='80_zone_beginn', tag='n80_zone_beginn') +STD_ANON.n90_zone_beginn = STD_ANON._CF_enumeration.addEnumeration(unicode_value='90_zone_beginn', tag='n90_zone_beginn') +STD_ANON.ende_10_zone = STD_ANON._CF_enumeration.addEnumeration(unicode_value='ende_10_zone', tag='ende_10_zone') +STD_ANON.ende_20_zone = STD_ANON._CF_enumeration.addEnumeration(unicode_value='ende_20_zone', tag='ende_20_zone') +STD_ANON.ende_40_zone = STD_ANON._CF_enumeration.addEnumeration(unicode_value='ende_40_zone', tag='ende_40_zone') +STD_ANON.ende_50_zone = STD_ANON._CF_enumeration.addEnumeration(unicode_value='ende_50_zone', tag='ende_50_zone') +STD_ANON.ende_60_zone = STD_ANON._CF_enumeration.addEnumeration(unicode_value='ende_60_zone', tag='ende_60_zone') +STD_ANON.ende_70_zone = STD_ANON._CF_enumeration.addEnumeration(unicode_value='ende_70_zone', tag='ende_70_zone') +STD_ANON.ende_80_zone = STD_ANON._CF_enumeration.addEnumeration(unicode_value='ende_80_zone', tag='ende_80_zone') +STD_ANON.ende_90_zone = STD_ANON._CF_enumeration.addEnumeration(unicode_value='ende_90_zone', tag='ende_90_zone') +STD_ANON.stvo_108_10 = STD_ANON._CF_enumeration.addEnumeration(unicode_value='stvo-108-10', tag='stvo_108_10') +STD_ANON.stvo_110_10 = STD_ANON._CF_enumeration.addEnumeration(unicode_value='stvo-110-10', tag='stvo_110_10') STD_ANON.stvo_306 = STD_ANON._CF_enumeration.addEnumeration(unicode_value='stvo-306', tag='stvo_306') STD_ANON.stvo_205 = STD_ANON._CF_enumeration.addEnumeration(unicode_value='stvo-205', tag='stvo_205') STD_ANON.stvo_206 = STD_ANON._CF_enumeration.addEnumeration(unicode_value='stvo-206', tag='stvo_206') STD_ANON.stvo_208 = STD_ANON._CF_enumeration.addEnumeration(unicode_value='stvo-208', tag='stvo_208') +STD_ANON.stvo_222 = STD_ANON._CF_enumeration.addEnumeration(unicode_value='stvo-222', tag='stvo_222') STD_ANON.stvo_276 = STD_ANON._CF_enumeration.addEnumeration(unicode_value='stvo-276', tag='stvo_276') STD_ANON.stvo_280 = STD_ANON._CF_enumeration.addEnumeration(unicode_value='stvo-280', tag='stvo_280') STD_ANON.stvo_274_1 = STD_ANON._CF_enumeration.addEnumeration(unicode_value='stvo-274.1', tag='stvo_274_1') STD_ANON.stvo_274_2 = STD_ANON._CF_enumeration.addEnumeration(unicode_value='stvo-274.2', tag='stvo_274_2') +STD_ANON.stvo_314 = STD_ANON._CF_enumeration.addEnumeration(unicode_value='stvo-314', tag='stvo_314') +STD_ANON.stvo_331_1 = STD_ANON._CF_enumeration.addEnumeration(unicode_value='stvo-331.1', tag='stvo_331_1') +STD_ANON.stvo_331_2 = STD_ANON._CF_enumeration.addEnumeration(unicode_value='stvo-331.2', tag='stvo_331_2') STD_ANON.stvo_350_10 = STD_ANON._CF_enumeration.addEnumeration(unicode_value='stvo-350-10', tag='stvo_350_10') STD_ANON.stvo_209_10 = STD_ANON._CF_enumeration.addEnumeration(unicode_value='stvo-209-10', tag='stvo_209_10') STD_ANON.stvo_209_20 = STD_ANON._CF_enumeration.addEnumeration(unicode_value='stvo-209-20', tag='stvo_209_20') @@ -207,9 +263,9 @@ class STD_ANON_ (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_m """An atomic simple type.""" _ExpandedName = None - _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 360, 12) + _XSDLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 447, 12) _Documentation = None -STD_ANON_._CF_enumeration = pyxb.binding.facets.CF_enumeration(enum_prefix=None, value_datatype=STD_ANON_) +STD_ANON_._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_, enum_prefix=None) STD_ANON_.n1_0 = STD_ANON_._CF_enumeration.addEnumeration(unicode_value='1.0', tag='n1_0') STD_ANON_._InitializeFacetMap(STD_ANON_._CF_enumeration) _module_typeBindings.STD_ANON_ = STD_ANON_ @@ -221,27 +277,27 @@ class floatInterval (pyxb.binding.basis.complexTypeDefinition): _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY _Abstract = False _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'floatInterval') - _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 19, 4) + _XSDLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 19, 4) _ElementMap = {} _AttributeMap = {} # Base type is pyxb.binding.datatypes.anyType # Element exact uses Python identifier exact - __exact = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'exact'), 'exact', '__AbsentNamespace0_floatInterval_exact', False, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 21, 12), ) + __exact = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'exact'), 'exact', '__AbsentNamespace0_floatInterval_exact', False, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 21, 12), ) exact = property(__exact.value, __exact.set, None, None) # Element intervalStart uses Python identifier intervalStart - __intervalStart = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'intervalStart'), 'intervalStart', '__AbsentNamespace0_floatInterval_intervalStart', False, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 23, 16), ) + __intervalStart = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'intervalStart'), 'intervalStart', '__AbsentNamespace0_floatInterval_intervalStart', False, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 23, 16), ) intervalStart = property(__intervalStart.value, __intervalStart.set, None, None) # Element intervalEnd uses Python identifier intervalEnd - __intervalEnd = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'intervalEnd'), 'intervalEnd', '__AbsentNamespace0_floatInterval_intervalEnd', False, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 24, 16), ) + __intervalEnd = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'intervalEnd'), 'intervalEnd', '__AbsentNamespace0_floatInterval_intervalEnd', False, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 24, 16), ) intervalEnd = property(__intervalEnd.value, __intervalEnd.set, None, None) @@ -265,20 +321,20 @@ class point (pyxb.binding.basis.complexTypeDefinition): _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY _Abstract = False _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'point') - _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 36, 4) + _XSDLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 36, 4) _ElementMap = {} _AttributeMap = {} # Base type is pyxb.binding.datatypes.anyType # Element x uses Python identifier x - __x = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'x'), 'x', '__AbsentNamespace0_point_x', False, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 38, 12), ) + __x = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'x'), 'x', '__AbsentNamespace0_point_x', False, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 38, 12), ) x = property(__x.value, __x.set, None, None) # Element y uses Python identifier y - __y = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'y'), 'y', '__AbsentNamespace0_point_y', False, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 39, 12), ) + __y = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'y'), 'y', '__AbsentNamespace0_point_y', False, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 39, 12), ) y = property(__y.value, __y.set, None, None) @@ -301,34 +357,34 @@ class rectangle (pyxb.binding.basis.complexTypeDefinition): _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY _Abstract = False _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'rectangle') - _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 55, 4) + _XSDLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 55, 4) _ElementMap = {} _AttributeMap = {} # Base type is pyxb.binding.datatypes.anyType # Element length uses Python identifier length - __length = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'length'), 'length', '__AbsentNamespace0_rectangle_length', False, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 57, 12), ) + __length = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'length'), 'length', '__AbsentNamespace0_rectangle_length', False, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 57, 12), ) length = property(__length.value, __length.set, None, None) # Element width uses Python identifier width - __width = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'width'), 'width', '__AbsentNamespace0_rectangle_width', False, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 58, 12), ) + __width = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'width'), 'width', '__AbsentNamespace0_rectangle_width', False, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 58, 12), ) width = property(__width.value, __width.set, None, None) # Element orientation uses Python identifier orientation - __orientation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'orientation'), 'orientation', '__AbsentNamespace0_rectangle_orientation', False, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 59, 12), ) + __orientation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'orientation'), 'orientation', '__AbsentNamespace0_rectangle_orientation', False, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 59, 12), ) orientation = property(__orientation.value, __orientation.set, None, None) # Element centerPoint uses Python identifier centerPoint - __centerPoint = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'centerPoint'), 'centerPoint', '__AbsentNamespace0_rectangle_centerPoint', False, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 60, 12), ) + __centerPoint = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'centerPoint'), 'centerPoint', '__AbsentNamespace0_rectangle_centerPoint', False, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 60, 12), ) centerPoint = property(__centerPoint.value, __centerPoint.set, None, None) @@ -353,20 +409,20 @@ class circle (pyxb.binding.basis.complexTypeDefinition): _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY _Abstract = False _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'circle') - _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 74, 4) + _XSDLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 74, 4) _ElementMap = {} _AttributeMap = {} # Base type is pyxb.binding.datatypes.anyType # Element radius uses Python identifier radius - __radius = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'radius'), 'radius', '__AbsentNamespace0_circle_radius', False, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 76, 12), ) + __radius = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'radius'), 'radius', '__AbsentNamespace0_circle_radius', False, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 76, 12), ) radius = property(__radius.value, __radius.set, None, None) # Element centerPoint uses Python identifier centerPoint - __centerPoint = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'centerPoint'), 'centerPoint', '__AbsentNamespace0_circle_centerPoint', False, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 77, 12), ) + __centerPoint = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'centerPoint'), 'centerPoint', '__AbsentNamespace0_circle_centerPoint', False, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 77, 12), ) centerPoint = property(__centerPoint.value, __centerPoint.set, None, None) @@ -389,13 +445,13 @@ class polygon (pyxb.binding.basis.complexTypeDefinition): _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY _Abstract = False _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'polygon') - _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 99, 4) + _XSDLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 99, 4) _ElementMap = {} _AttributeMap = {} # Base type is pyxb.binding.datatypes.anyType # Element point uses Python identifier point - __point = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'point'), 'point', '__AbsentNamespace0_polygon_point', True, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 101, 12), ) + __point = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'point'), 'point', '__AbsentNamespace0_polygon_point', True, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 101, 12), ) point = property(__point.value, __point.set, None, None) @@ -417,27 +473,27 @@ class shape (pyxb.binding.basis.complexTypeDefinition): _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY _Abstract = False _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'shape') - _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 117, 4) + _XSDLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 117, 4) _ElementMap = {} _AttributeMap = {} # Base type is pyxb.binding.datatypes.anyType # Element rectangle uses Python identifier rectangle - __rectangle = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'rectangle'), 'rectangle', '__AbsentNamespace0_shape_rectangle', True, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 119, 12), ) + __rectangle = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'rectangle'), 'rectangle', '__AbsentNamespace0_shape_rectangle', True, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 119, 12), ) rectangle = property(__rectangle.value, __rectangle.set, None, None) # Element circle uses Python identifier circle - __circle = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'circle'), 'circle', '__AbsentNamespace0_shape_circle', True, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 120, 12), ) + __circle = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'circle'), 'circle', '__AbsentNamespace0_shape_circle', True, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 120, 12), ) circle = property(__circle.value, __circle.set, None, None) # Element polygon uses Python identifier polygon - __polygon = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'polygon'), 'polygon', '__AbsentNamespace0_shape_polygon', True, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 121, 12), ) + __polygon = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'polygon'), 'polygon', '__AbsentNamespace0_shape_polygon', True, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 121, 12), ) polygon = property(__polygon.value, __polygon.set, None, None) @@ -461,20 +517,20 @@ class occupancy (pyxb.binding.basis.complexTypeDefinition): _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY _Abstract = False _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'occupancy') - _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 125, 4) + _XSDLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 125, 4) _ElementMap = {} _AttributeMap = {} # Base type is pyxb.binding.datatypes.anyType # Element shape uses Python identifier shape - __shape = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'shape'), 'shape', '__AbsentNamespace0_occupancy_shape', False, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 127, 12), ) + __shape = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'shape'), 'shape', '__AbsentNamespace0_occupancy_shape', False, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 127, 12), ) shape = property(__shape.value, __shape.set, None, None) # Element time uses Python identifier time - __time = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'time'), 'time', '__AbsentNamespace0_occupancy_time', False, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 128, 12), ) + __time = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'time'), 'time', '__AbsentNamespace0_occupancy_time', False, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 128, 12), ) time = property(__time.value, __time.set, None, None) @@ -497,41 +553,41 @@ class state (pyxb.binding.basis.complexTypeDefinition): _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY _Abstract = False _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'state') - _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 132, 4) + _XSDLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 132, 4) _ElementMap = {} _AttributeMap = {} # Base type is pyxb.binding.datatypes.anyType # Element position uses Python identifier position - __position = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'position'), 'position', '__AbsentNamespace0_state_position', False, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 134, 12), ) + __position = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'position'), 'position', '__AbsentNamespace0_state_position', False, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 134, 12), ) position = property(__position.value, __position.set, None, None) # Element orientation uses Python identifier orientation - __orientation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'orientation'), 'orientation', '__AbsentNamespace0_state_orientation', False, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 146, 12), ) + __orientation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'orientation'), 'orientation', '__AbsentNamespace0_state_orientation', False, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 146, 12), ) orientation = property(__orientation.value, __orientation.set, None, None) # Element time uses Python identifier time - __time = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'time'), 'time', '__AbsentNamespace0_state_time', False, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 147, 12), ) + __time = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'time'), 'time', '__AbsentNamespace0_state_time', False, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 147, 12), ) time = property(__time.value, __time.set, None, None) # Element velocity uses Python identifier velocity - __velocity = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'velocity'), 'velocity', '__AbsentNamespace0_state_velocity', False, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 148, 12), ) + __velocity = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'velocity'), 'velocity', '__AbsentNamespace0_state_velocity', False, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 148, 12), ) velocity = property(__velocity.value, __velocity.set, None, None) # Element acceleration uses Python identifier acceleration - __acceleration = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'acceleration'), 'acceleration', '__AbsentNamespace0_state_acceleration', False, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 149, 12), ) + __acceleration = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'acceleration'), 'acceleration', '__AbsentNamespace0_state_acceleration', False, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 149, 12), ) acceleration = property(__acceleration.value, __acceleration.set, None, None) @@ -557,34 +613,34 @@ class CTD_ANON (pyxb.binding.basis.complexTypeDefinition): _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY _Abstract = False _ExpandedName = None - _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 135, 16) + _XSDLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 135, 16) _ElementMap = {} _AttributeMap = {} # Base type is pyxb.binding.datatypes.anyType # Element point uses Python identifier point - __point = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'point'), 'point', '__AbsentNamespace0_CTD_ANON_point', False, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 137, 24), ) + __point = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'point'), 'point', '__AbsentNamespace0_CTD_ANON_point', False, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 137, 24), ) point = property(__point.value, __point.set, None, None) # Element rectangle uses Python identifier rectangle - __rectangle = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'rectangle'), 'rectangle', '__AbsentNamespace0_CTD_ANON_rectangle', True, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 139, 28), ) + __rectangle = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'rectangle'), 'rectangle', '__AbsentNamespace0_CTD_ANON_rectangle', True, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 139, 28), ) rectangle = property(__rectangle.value, __rectangle.set, None, None) # Element circle uses Python identifier circle - __circle = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'circle'), 'circle', '__AbsentNamespace0_CTD_ANON_circle', True, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 140, 28), ) + __circle = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'circle'), 'circle', '__AbsentNamespace0_CTD_ANON_circle', True, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 140, 28), ) circle = property(__circle.value, __circle.set, None, None) # Element polygon uses Python identifier polygon - __polygon = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'polygon'), 'polygon', '__AbsentNamespace0_CTD_ANON_polygon', True, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 141, 28), ) + __polygon = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'polygon'), 'polygon', '__AbsentNamespace0_CTD_ANON_polygon', True, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 141, 28), ) polygon = property(__polygon.value, __polygon.set, None, None) @@ -608,41 +664,41 @@ class obstacle (pyxb.binding.basis.complexTypeDefinition): _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY _Abstract = False _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'obstacle') - _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 179, 4) + _XSDLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 180, 4) _ElementMap = {} _AttributeMap = {} # Base type is pyxb.binding.datatypes.anyType # Element role uses Python identifier role - __role = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'role'), 'role', '__AbsentNamespace0_obstacle_role', False, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 181, 12), ) + __role = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'role'), 'role', '__AbsentNamespace0_obstacle_role', False, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 182, 12), ) role = property(__role.value, __role.set, None, None) # Element type uses Python identifier type - __type = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'type'), 'type', '__AbsentNamespace0_obstacle_type', False, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 182, 12), ) + __type = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'type'), 'type', '__AbsentNamespace0_obstacle_type', False, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 183, 12), ) type = property(__type.value, __type.set, None, None) # Element shape uses Python identifier shape - __shape = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'shape'), 'shape', '__AbsentNamespace0_obstacle_shape', False, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 183, 12), ) + __shape = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'shape'), 'shape', '__AbsentNamespace0_obstacle_shape', False, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 184, 12), ) shape = property(__shape.value, __shape.set, None, None) # Element trajectory uses Python identifier trajectory - __trajectory = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'trajectory'), 'trajectory', '__AbsentNamespace0_obstacle_trajectory', False, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 185, 16), ) + __trajectory = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'trajectory'), 'trajectory', '__AbsentNamespace0_obstacle_trajectory', False, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 186, 16), ) trajectory = property(__trajectory.value, __trajectory.set, None, None) # Element occupancySet uses Python identifier occupancySet - __occupancySet = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'occupancySet'), 'occupancySet', '__AbsentNamespace0_obstacle_occupancySet', False, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 193, 16), ) + __occupancySet = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'occupancySet'), 'occupancySet', '__AbsentNamespace0_obstacle_occupancySet', False, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 194, 16), ) occupancySet = property(__occupancySet.value, __occupancySet.set, None, None) @@ -650,8 +706,8 @@ class obstacle (pyxb.binding.basis.complexTypeDefinition): # Attribute id uses Python identifier id __id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'id'), 'id', '__AbsentNamespace0_obstacle_id', pyxb.binding.datatypes.integer, required=True) - __id._DeclarationLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 203, 8) - __id._UseLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 203, 8) + __id._DeclarationLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 204, 8) + __id._UseLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 204, 8) id = property(__id.value, __id.set, None, None) @@ -676,13 +732,13 @@ class CTD_ANON_ (pyxb.binding.basis.complexTypeDefinition): _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY _Abstract = False _ExpandedName = None - _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 186, 20) + _XSDLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 187, 20) _ElementMap = {} _AttributeMap = {} # Base type is pyxb.binding.datatypes.anyType # Element state uses Python identifier state - __state = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'state'), 'state', '__AbsentNamespace0_CTD_ANON__state', True, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 188, 28), ) + __state = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'state'), 'state', '__AbsentNamespace0_CTD_ANON__state', True, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 189, 28), ) state = property(__state.value, __state.set, None, None) @@ -703,13 +759,13 @@ class CTD_ANON_2 (pyxb.binding.basis.complexTypeDefinition): _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY _Abstract = False _ExpandedName = None - _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 194, 20) + _XSDLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 195, 20) _ElementMap = {} _AttributeMap = {} # Base type is pyxb.binding.datatypes.anyType # Element occupancy uses Python identifier occupancy - __occupancy = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'occupancy'), 'occupancy', '__AbsentNamespace0_CTD_ANON_2_occupancy', True, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 196, 28), ) + __occupancy = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'occupancy'), 'occupancy', '__AbsentNamespace0_CTD_ANON_2_occupancy', True, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 197, 28), ) occupancy = property(__occupancy.value, __occupancy.set, None, None) @@ -730,20 +786,20 @@ class boundary (pyxb.binding.basis.complexTypeDefinition): _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY _Abstract = False _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'boundary') - _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 213, 4) + _XSDLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 214, 4) _ElementMap = {} _AttributeMap = {} # Base type is pyxb.binding.datatypes.anyType # Element point uses Python identifier point - __point = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'point'), 'point', '__AbsentNamespace0_boundary_point', True, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 215, 12), ) + __point = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'point'), 'point', '__AbsentNamespace0_boundary_point', True, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 216, 12), ) point = property(__point.value, __point.set, None, None) # Element lineMarking uses Python identifier lineMarking - __lineMarking = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'lineMarking'), 'lineMarking', '__AbsentNamespace0_boundary_lineMarking', False, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 217, 12), ) + __lineMarking = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'lineMarking'), 'lineMarking', '__AbsentNamespace0_boundary_lineMarking', False, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 218, 12), ) lineMarking = property(__lineMarking.value, __lineMarking.set, None, None) @@ -759,6 +815,50 @@ class boundary (pyxb.binding.basis.complexTypeDefinition): Namespace.addCategoryObject('typeBinding', 'boundary', boundary) +# Complex type lineMarkingAttributes with content type ELEMENT_ONLY +class lineMarkingAttributes (pyxb.binding.basis.complexTypeDefinition): + """Complex type lineMarkingAttributes with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'lineMarkingAttributes') + _XSDLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 223, 4) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element lineWidth uses Python identifier lineWidth + __lineWidth = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'lineWidth'), 'lineWidth', '__AbsentNamespace0_lineMarkingAttributes_lineWidth', False, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 225, 12), ) + + + lineWidth = property(__lineWidth.value, __lineWidth.set, None, None) + + + # Element segmentLength uses Python identifier segmentLength + __segmentLength = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'segmentLength'), 'segmentLength', '__AbsentNamespace0_lineMarkingAttributes_segmentLength', False, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 226, 12), ) + + + segmentLength = property(__segmentLength.value, __segmentLength.set, None, None) + + + # Element segmentGap uses Python identifier segmentGap + __segmentGap = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'segmentGap'), 'segmentGap', '__AbsentNamespace0_lineMarkingAttributes_segmentGap', False, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 227, 12), ) + + + segmentGap = property(__segmentGap.value, __segmentGap.set, None, None) + + _ElementMap.update({ + __lineWidth.name() : __lineWidth, + __segmentLength.name() : __segmentLength, + __segmentGap.name() : __segmentGap + }) + _AttributeMap.update({ + + }) +_module_typeBindings.lineMarkingAttributes = lineMarkingAttributes +Namespace.addCategoryObject('typeBinding', 'lineMarkingAttributes', lineMarkingAttributes) + + # Complex type laneletRef with content type EMPTY class laneletRef (pyxb.binding.basis.complexTypeDefinition): """Complex type laneletRef with content type EMPTY""" @@ -766,15 +866,15 @@ class laneletRef (pyxb.binding.basis.complexTypeDefinition): _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY _Abstract = False _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'laneletRef') - _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 222, 4) + _XSDLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 232, 4) _ElementMap = {} _AttributeMap = {} # Base type is pyxb.binding.datatypes.anyType # Attribute ref uses Python identifier ref __ref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ref'), 'ref', '__AbsentNamespace0_laneletRef_ref', pyxb.binding.datatypes.integer, required=True) - __ref._DeclarationLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 223, 8) - __ref._UseLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 223, 8) + __ref._DeclarationLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 233, 8) + __ref._UseLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 233, 8) ref = property(__ref.value, __ref.set, None, None) @@ -795,13 +895,13 @@ class laneletRefList (pyxb.binding.basis.complexTypeDefinition): _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY _Abstract = False _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'laneletRefList') - _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 227, 4) + _XSDLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 237, 4) _ElementMap = {} _AttributeMap = {} # Base type is pyxb.binding.datatypes.anyType # Element lanelet uses Python identifier lanelet - __lanelet = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'lanelet'), 'lanelet', '__AbsentNamespace0_laneletRefList_lanelet', True, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 229, 12), ) + __lanelet = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'lanelet'), 'lanelet', '__AbsentNamespace0_laneletRefList_lanelet', True, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 239, 12), ) lanelet = property(__lanelet.value, __lanelet.set, None, None) @@ -823,78 +923,85 @@ class lanelet (pyxb.binding.basis.complexTypeDefinition): _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY _Abstract = False _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'lanelet') - _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 255, 4) + _XSDLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 265, 4) _ElementMap = {} _AttributeMap = {} # Base type is pyxb.binding.datatypes.anyType # Element type uses Python identifier type - __type = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'type'), 'type', '__AbsentNamespace0_lanelet_type', False, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 257, 12), ) + __type = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'type'), 'type', '__AbsentNamespace0_lanelet_type', False, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 267, 12), ) type = property(__type.value, __type.set, None, None) # Element isStart uses Python identifier isStart - __isStart = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'isStart'), 'isStart', '__AbsentNamespace0_lanelet_isStart', False, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 258, 12), ) + __isStart = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'isStart'), 'isStart', '__AbsentNamespace0_lanelet_isStart', False, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 268, 12), ) isStart = property(__isStart.value, __isStart.set, None, None) # Element leftBoundary uses Python identifier leftBoundary - __leftBoundary = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'leftBoundary'), 'leftBoundary', '__AbsentNamespace0_lanelet_leftBoundary', False, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 259, 12), ) + __leftBoundary = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'leftBoundary'), 'leftBoundary', '__AbsentNamespace0_lanelet_leftBoundary', False, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 269, 12), ) leftBoundary = property(__leftBoundary.value, __leftBoundary.set, None, None) # Element rightBoundary uses Python identifier rightBoundary - __rightBoundary = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'rightBoundary'), 'rightBoundary', '__AbsentNamespace0_lanelet_rightBoundary', False, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 260, 12), ) + __rightBoundary = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'rightBoundary'), 'rightBoundary', '__AbsentNamespace0_lanelet_rightBoundary', False, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 270, 12), ) rightBoundary = property(__rightBoundary.value, __rightBoundary.set, None, None) # Element predecessor uses Python identifier predecessor - __predecessor = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'predecessor'), 'predecessor', '__AbsentNamespace0_lanelet_predecessor', False, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 261, 12), ) + __predecessor = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'predecessor'), 'predecessor', '__AbsentNamespace0_lanelet_predecessor', False, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 271, 12), ) predecessor = property(__predecessor.value, __predecessor.set, None, None) # Element successor uses Python identifier successor - __successor = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'successor'), 'successor', '__AbsentNamespace0_lanelet_successor', False, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 263, 12), ) + __successor = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'successor'), 'successor', '__AbsentNamespace0_lanelet_successor', False, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 273, 12), ) successor = property(__successor.value, __successor.set, None, None) # Element adjacentLeft uses Python identifier adjacentLeft - __adjacentLeft = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'adjacentLeft'), 'adjacentLeft', '__AbsentNamespace0_lanelet_adjacentLeft', False, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 265, 12), ) + __adjacentLeft = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'adjacentLeft'), 'adjacentLeft', '__AbsentNamespace0_lanelet_adjacentLeft', False, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 275, 12), ) adjacentLeft = property(__adjacentLeft.value, __adjacentLeft.set, None, None) # Element adjacentRight uses Python identifier adjacentRight - __adjacentRight = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'adjacentRight'), 'adjacentRight', '__AbsentNamespace0_lanelet_adjacentRight', False, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 267, 12), ) + __adjacentRight = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'adjacentRight'), 'adjacentRight', '__AbsentNamespace0_lanelet_adjacentRight', False, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 277, 12), ) adjacentRight = property(__adjacentRight.value, __adjacentRight.set, None, None) # Element stopLine uses Python identifier stopLine - __stopLine = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'stopLine'), 'stopLine', '__AbsentNamespace0_lanelet_stopLine', False, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 270, 12), ) + __stopLine = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'stopLine'), 'stopLine', '__AbsentNamespace0_lanelet_stopLine', False, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 280, 12), ) stopLine = property(__stopLine.value, __stopLine.set, None, None) + # Element stopLineAttributes uses Python identifier stopLineAttributes + __stopLineAttributes = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'stopLineAttributes'), 'stopLineAttributes', '__AbsentNamespace0_lanelet_stopLineAttributes', False, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 281, 12), ) + + + stopLineAttributes = property(__stopLineAttributes.value, __stopLineAttributes.set, None, None) + + # Attribute id uses Python identifier id __id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'id'), 'id', '__AbsentNamespace0_lanelet_id', pyxb.binding.datatypes.integer, required=True) - __id._DeclarationLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 272, 8) - __id._UseLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 272, 8) + __id._DeclarationLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 283, 8) + __id._UseLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 283, 8) id = property(__id.value, __id.set, None, None) @@ -907,7 +1014,8 @@ class lanelet (pyxb.binding.basis.complexTypeDefinition): __successor.name() : __successor, __adjacentLeft.name() : __adjacentLeft, __adjacentRight.name() : __adjacentRight, - __stopLine.name() : __stopLine + __stopLine.name() : __stopLine, + __stopLineAttributes.name() : __stopLineAttributes }) _AttributeMap.update({ __id.name() : __id @@ -923,34 +1031,34 @@ class egoVehicle (pyxb.binding.basis.complexTypeDefinition): _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY _Abstract = False _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'egoVehicle') - _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 275, 4) + _XSDLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 286, 4) _ElementMap = {} _AttributeMap = {} # Base type is pyxb.binding.datatypes.anyType # Element type uses Python identifier type - __type = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'type'), 'type', '__AbsentNamespace0_egoVehicle_type', False, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 277, 12), ) + __type = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'type'), 'type', '__AbsentNamespace0_egoVehicle_type', False, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 288, 12), ) type = property(__type.value, __type.set, None, None) # Element shape uses Python identifier shape - __shape = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'shape'), 'shape', '__AbsentNamespace0_egoVehicle_shape', False, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 278, 12), ) + __shape = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'shape'), 'shape', '__AbsentNamespace0_egoVehicle_shape', False, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 289, 12), ) shape = property(__shape.value, __shape.set, None, None) # Element initialState uses Python identifier initialState - __initialState = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'initialState'), 'initialState', '__AbsentNamespace0_egoVehicle_initialState', False, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 279, 12), ) + __initialState = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'initialState'), 'initialState', '__AbsentNamespace0_egoVehicle_initialState', False, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 290, 12), ) initialState = property(__initialState.value, __initialState.set, None, None) # Element goalRegion uses Python identifier goalRegion - __goalRegion = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'goalRegion'), 'goalRegion', '__AbsentNamespace0_egoVehicle_goalRegion', False, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 280, 12), ) + __goalRegion = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'goalRegion'), 'goalRegion', '__AbsentNamespace0_egoVehicle_goalRegion', False, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 291, 12), ) goalRegion = property(__goalRegion.value, __goalRegion.set, None, None) @@ -958,8 +1066,8 @@ class egoVehicle (pyxb.binding.basis.complexTypeDefinition): # Attribute id uses Python identifier id __id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'id'), 'id', '__AbsentNamespace0_egoVehicle_id', pyxb.binding.datatypes.integer, required=True) - __id._DeclarationLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 289, 8) - __id._UseLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 289, 8) + __id._DeclarationLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 300, 8) + __id._UseLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 300, 8) id = property(__id.value, __id.set, None, None) @@ -983,13 +1091,13 @@ class CTD_ANON_3 (pyxb.binding.basis.complexTypeDefinition): _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY _Abstract = False _ExpandedName = None - _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 281, 16) + _XSDLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 292, 16) _ElementMap = {} _AttributeMap = {} # Base type is pyxb.binding.datatypes.anyType # Element state uses Python identifier state - __state = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'state'), 'state', '__AbsentNamespace0_CTD_ANON_3_state', True, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 283, 24), ) + __state = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'state'), 'state', '__AbsentNamespace0_CTD_ANON_3_state', True, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 294, 24), ) state = property(__state.value, __state.set, None, None) @@ -1010,13 +1118,13 @@ class parkingLot (pyxb.binding.basis.complexTypeDefinition): _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY _Abstract = False _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'parkingLot') - _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 293, 4) + _XSDLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 304, 4) _ElementMap = {} _AttributeMap = {} # Base type is pyxb.binding.datatypes.anyType # Element shape uses Python identifier shape - __shape = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'shape'), 'shape', '__AbsentNamespace0_parkingLot_shape', False, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 295, 12), ) + __shape = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'shape'), 'shape', '__AbsentNamespace0_parkingLot_shape', False, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 306, 12), ) shape = property(__shape.value, __shape.set, None, None) @@ -1024,8 +1132,8 @@ class parkingLot (pyxb.binding.basis.complexTypeDefinition): # Attribute id uses Python identifier id __id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'id'), 'id', '__AbsentNamespace0_parkingLot_id', pyxb.binding.datatypes.integer, required=True) - __id._DeclarationLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 297, 8) - __id._UseLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 297, 8) + __id._DeclarationLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 308, 8) + __id._UseLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 308, 8) id = property(__id.value, __id.set, None, None) @@ -1039,6 +1147,86 @@ class parkingLot (pyxb.binding.basis.complexTypeDefinition): Namespace.addCategoryObject('typeBinding', 'parkingLot', parkingLot) +# Complex type trafficIslandJunction with content type ELEMENT_ONLY +class trafficIslandJunction (pyxb.binding.basis.complexTypeDefinition): + """Complex type trafficIslandJunction with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'trafficIslandJunction') + _XSDLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 311, 4) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element point uses Python identifier point + __point = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'point'), 'point', '__AbsentNamespace0_trafficIslandJunction_point', True, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 313, 12), ) + + + point = property(__point.value, __point.set, None, None) + + _ElementMap.update({ + __point.name() : __point + }) + _AttributeMap.update({ + + }) +_module_typeBindings.trafficIslandJunction = trafficIslandJunction +Namespace.addCategoryObject('typeBinding', 'trafficIslandJunction', trafficIslandJunction) + + +# Complex type roadMarking with content type ELEMENT_ONLY +class roadMarking (pyxb.binding.basis.complexTypeDefinition): + """Complex type roadMarking with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'roadMarking') + _XSDLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 342, 4) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element type uses Python identifier type + __type = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'type'), 'type', '__AbsentNamespace0_roadMarking_type', False, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 344, 12), ) + + + type = property(__type.value, __type.set, None, None) + + + # Element orientation uses Python identifier orientation + __orientation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'orientation'), 'orientation', '__AbsentNamespace0_roadMarking_orientation', False, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 345, 12), ) + + + orientation = property(__orientation.value, __orientation.set, None, None) + + + # Element centerPoint uses Python identifier centerPoint + __centerPoint = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'centerPoint'), 'centerPoint', '__AbsentNamespace0_roadMarking_centerPoint', False, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 346, 12), ) + + + centerPoint = property(__centerPoint.value, __centerPoint.set, None, None) + + + # Attribute id uses Python identifier id + __id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'id'), 'id', '__AbsentNamespace0_roadMarking_id', pyxb.binding.datatypes.integer, required=True) + __id._DeclarationLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 348, 8) + __id._UseLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 348, 8) + + id = property(__id.value, __id.set, None, None) + + _ElementMap.update({ + __type.name() : __type, + __orientation.name() : __orientation, + __centerPoint.name() : __centerPoint + }) + _AttributeMap.update({ + __id.name() : __id + }) +_module_typeBindings.roadMarking = roadMarking +Namespace.addCategoryObject('typeBinding', 'roadMarking', roadMarking) + + # Complex type trafficSign with content type ELEMENT_ONLY class trafficSign (pyxb.binding.basis.complexTypeDefinition): """Complex type trafficSign with content type ELEMENT_ONLY""" @@ -1046,27 +1234,27 @@ class trafficSign (pyxb.binding.basis.complexTypeDefinition): _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY _Abstract = False _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'trafficSign') - _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 301, 4) + _XSDLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 352, 4) _ElementMap = {} _AttributeMap = {} # Base type is pyxb.binding.datatypes.anyType # Element type uses Python identifier type - __type = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'type'), 'type', '__AbsentNamespace0_trafficSign_type', False, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 303, 12), ) + __type = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'type'), 'type', '__AbsentNamespace0_trafficSign_type', False, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 354, 12), ) type = property(__type.value, __type.set, None, None) # Element orientation uses Python identifier orientation - __orientation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'orientation'), 'orientation', '__AbsentNamespace0_trafficSign_orientation', False, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 324, 12), ) + __orientation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'orientation'), 'orientation', '__AbsentNamespace0_trafficSign_orientation', False, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 397, 12), ) orientation = property(__orientation.value, __orientation.set, None, None) # Element centerPoint uses Python identifier centerPoint - __centerPoint = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'centerPoint'), 'centerPoint', '__AbsentNamespace0_trafficSign_centerPoint', False, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 325, 12), ) + __centerPoint = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'centerPoint'), 'centerPoint', '__AbsentNamespace0_trafficSign_centerPoint', False, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 398, 12), ) centerPoint = property(__centerPoint.value, __centerPoint.set, None, None) @@ -1074,8 +1262,8 @@ class trafficSign (pyxb.binding.basis.complexTypeDefinition): # Attribute id uses Python identifier id __id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'id'), 'id', '__AbsentNamespace0_trafficSign_id', pyxb.binding.datatypes.integer, required=True) - __id._DeclarationLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 327, 8) - __id._UseLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 327, 8) + __id._DeclarationLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 400, 8) + __id._UseLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 400, 8) id = property(__id.value, __id.set, None, None) @@ -1091,6 +1279,50 @@ class trafficSign (pyxb.binding.basis.complexTypeDefinition): Namespace.addCategoryObject('typeBinding', 'trafficSign', trafficSign) +# Complex type ramp with content type ELEMENT_ONLY +class ramp (pyxb.binding.basis.complexTypeDefinition): + """Complex type ramp with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'ramp') + _XSDLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 403, 4) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element orientation uses Python identifier orientation + __orientation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'orientation'), 'orientation', '__AbsentNamespace0_ramp_orientation', False, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 405, 12), ) + + + orientation = property(__orientation.value, __orientation.set, None, None) + + + # Element centerPoint uses Python identifier centerPoint + __centerPoint = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'centerPoint'), 'centerPoint', '__AbsentNamespace0_ramp_centerPoint', False, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 406, 12), ) + + + centerPoint = property(__centerPoint.value, __centerPoint.set, None, None) + + + # Attribute id uses Python identifier id + __id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'id'), 'id', '__AbsentNamespace0_ramp_id', pyxb.binding.datatypes.integer, required=True) + __id._DeclarationLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 408, 8) + __id._UseLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 408, 8) + + id = property(__id.value, __id.set, None, None) + + _ElementMap.update({ + __orientation.name() : __orientation, + __centerPoint.name() : __centerPoint + }) + _AttributeMap.update({ + __id.name() : __id + }) +_module_typeBindings.ramp = ramp +Namespace.addCategoryObject('typeBinding', 'ramp', ramp) + + # Complex type intersection with content type ELEMENT_ONLY class intersection (pyxb.binding.basis.complexTypeDefinition): """Complex type intersection with content type ELEMENT_ONLY""" @@ -1098,20 +1330,20 @@ class intersection (pyxb.binding.basis.complexTypeDefinition): _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY _Abstract = False _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'intersection') - _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 331, 4) + _XSDLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 412, 4) _ElementMap = {} _AttributeMap = {} # Base type is pyxb.binding.datatypes.anyType # Element composition uses Python identifier composition - __composition = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'composition'), 'composition', '__AbsentNamespace0_intersection_composition', False, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 333, 12), ) + __composition = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'composition'), 'composition', '__AbsentNamespace0_intersection_composition', False, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 414, 12), ) composition = property(__composition.value, __composition.set, None, None) # Element priority uses Python identifier priority - __priority = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'priority'), 'priority', '__AbsentNamespace0_intersection_priority', True, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 334, 12), ) + __priority = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'priority'), 'priority', '__AbsentNamespace0_intersection_priority', True, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 415, 12), ) priority = property(__priority.value, __priority.set, None, None) @@ -1119,8 +1351,8 @@ class intersection (pyxb.binding.basis.complexTypeDefinition): # Attribute id uses Python identifier id __id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'id'), 'id', '__AbsentNamespace0_intersection_id', pyxb.binding.datatypes.integer, required=True) - __id._DeclarationLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 341, 8) - __id._UseLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 341, 8) + __id._DeclarationLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 422, 8) + __id._UseLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 422, 8) id = property(__id.value, __id.set, None, None) @@ -1142,23 +1374,23 @@ class CTD_ANON_4 (pyxb.binding.basis.complexTypeDefinition): _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY _Abstract = False _ExpandedName = None - _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 335, 16) + _XSDLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 416, 16) _ElementMap = {} _AttributeMap = {} # Base type is pyxb.binding.datatypes.anyType # Attribute low uses Python identifier low __low = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'low'), 'low', '__AbsentNamespace0_CTD_ANON_4_low', pyxb.binding.datatypes.integer, required=True) - __low._DeclarationLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 336, 20) - __low._UseLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 336, 20) + __low._DeclarationLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 417, 20) + __low._UseLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 417, 20) low = property(__low.value, __low.set, None, None) # Attribute high uses Python identifier high __high = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'high'), 'high', '__AbsentNamespace0_CTD_ANON_4_high', pyxb.binding.datatypes.integer, required=True) - __high._DeclarationLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 337, 20) - __high._UseLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 337, 20) + __high._DeclarationLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 418, 20) + __high._UseLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 418, 20) high = property(__high.value, __high.set, None, None) @@ -1179,23 +1411,23 @@ class laneletAdjacentRef (pyxb.binding.basis.complexTypeDefinition): _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY _Abstract = False _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'laneletAdjacentRef') - _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 241, 4) + _XSDLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 251, 4) _ElementMap = {} _AttributeMap = {} # Base type is pyxb.binding.datatypes.anyType # Attribute ref uses Python identifier ref __ref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ref'), 'ref', '__AbsentNamespace0_laneletAdjacentRef_ref', pyxb.binding.datatypes.integer, required=True) - __ref._DeclarationLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 242, 8) - __ref._UseLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 242, 8) + __ref._DeclarationLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 252, 8) + __ref._UseLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 252, 8) ref = property(__ref.value, __ref.set, None, None) # Attribute drivingDir uses Python identifier drivingDir __drivingDir = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'drivingDir'), 'drivingDir', '__AbsentNamespace0_laneletAdjacentRef_drivingDir', _module_typeBindings.drivingDir, required=True) - __drivingDir._DeclarationLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 243, 8) - __drivingDir._UseLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 243, 8) + __drivingDir._DeclarationLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 253, 8) + __drivingDir._UseLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 253, 8) drivingDir = property(__drivingDir.value, __drivingDir.set, None, None) @@ -1217,81 +1449,102 @@ class CommonRoad (pyxb.binding.basis.complexTypeDefinition): _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY _Abstract = False _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'CommonRoad') - _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 344, 4) + _XSDLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 425, 4) _ElementMap = {} _AttributeMap = {} # Base type is pyxb.binding.datatypes.anyType # Element obstacle uses Python identifier obstacle - __obstacle = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'obstacle'), 'obstacle', '__AbsentNamespace0_CommonRoad_obstacle', True, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 346, 12), ) + __obstacle = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'obstacle'), 'obstacle', '__AbsentNamespace0_CommonRoad_obstacle', True, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 427, 12), ) obstacle = property(__obstacle.value, __obstacle.set, None, None) # Element lanelet uses Python identifier lanelet - __lanelet = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'lanelet'), 'lanelet', '__AbsentNamespace0_CommonRoad_lanelet', True, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 348, 12), ) + __lanelet = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'lanelet'), 'lanelet', '__AbsentNamespace0_CommonRoad_lanelet', True, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 429, 12), ) lanelet = property(__lanelet.value, __lanelet.set, None, None) # Element egoVehicle uses Python identifier egoVehicle - __egoVehicle = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'egoVehicle'), 'egoVehicle', '__AbsentNamespace0_CommonRoad_egoVehicle', True, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 350, 12), ) + __egoVehicle = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'egoVehicle'), 'egoVehicle', '__AbsentNamespace0_CommonRoad_egoVehicle', True, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 431, 12), ) egoVehicle = property(__egoVehicle.value, __egoVehicle.set, None, None) # Element parkingLot uses Python identifier parkingLot - __parkingLot = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'parkingLot'), 'parkingLot', '__AbsentNamespace0_CommonRoad_parkingLot', True, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 352, 12), ) + __parkingLot = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'parkingLot'), 'parkingLot', '__AbsentNamespace0_CommonRoad_parkingLot', True, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 433, 12), ) parkingLot = property(__parkingLot.value, __parkingLot.set, None, None) # Element trafficSign uses Python identifier trafficSign - __trafficSign = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'trafficSign'), 'trafficSign', '__AbsentNamespace0_CommonRoad_trafficSign', True, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 354, 12), ) + __trafficSign = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'trafficSign'), 'trafficSign', '__AbsentNamespace0_CommonRoad_trafficSign', True, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 435, 12), ) trafficSign = property(__trafficSign.value, __trafficSign.set, None, None) + # Element ramp uses Python identifier ramp + __ramp = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'ramp'), 'ramp', '__AbsentNamespace0_CommonRoad_ramp', True, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 437, 12), ) + + + ramp = property(__ramp.value, __ramp.set, None, None) + + # Element intersection uses Python identifier intersection - __intersection = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'intersection'), 'intersection', '__AbsentNamespace0_CommonRoad_intersection', True, pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 356, 12), ) + __intersection = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'intersection'), 'intersection', '__AbsentNamespace0_CommonRoad_intersection', True, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 439, 12), ) intersection = property(__intersection.value, __intersection.set, None, None) + # Element islandJunction uses Python identifier islandJunction + __islandJunction = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'islandJunction'), 'islandJunction', '__AbsentNamespace0_CommonRoad_islandJunction', True, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 441, 12), ) + + + islandJunction = property(__islandJunction.value, __islandJunction.set, None, None) + + + # Element roadMarking uses Python identifier roadMarking + __roadMarking = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'roadMarking'), 'roadMarking', '__AbsentNamespace0_CommonRoad_roadMarking', True, pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 443, 12), ) + + + roadMarking = property(__roadMarking.value, __roadMarking.set, None, None) + + # Attribute commonRoadVersion uses Python identifier commonRoadVersion __commonRoadVersion = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'commonRoadVersion'), 'commonRoadVersion', '__AbsentNamespace0_CommonRoad_commonRoadVersion', _module_typeBindings.STD_ANON_, required=True) - __commonRoadVersion._DeclarationLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 359, 8) - __commonRoadVersion._UseLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 359, 8) + __commonRoadVersion._DeclarationLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 446, 8) + __commonRoadVersion._UseLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 446, 8) commonRoadVersion = property(__commonRoadVersion.value, __commonRoadVersion.set, None, None) # Attribute benchmarkID uses Python identifier benchmarkID __benchmarkID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'benchmarkID'), 'benchmarkID', '__AbsentNamespace0_CommonRoad_benchmarkID', pyxb.binding.datatypes.string) - __benchmarkID._DeclarationLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 366, 8) - __benchmarkID._UseLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 366, 8) + __benchmarkID._DeclarationLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 453, 8) + __benchmarkID._UseLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 453, 8) benchmarkID = property(__benchmarkID.value, __benchmarkID.set, None, None) # Attribute date uses Python identifier date __date = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'date'), 'date', '__AbsentNamespace0_CommonRoad_date', pyxb.binding.datatypes.date) - __date._DeclarationLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 367, 8) - __date._UseLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 367, 8) + __date._DeclarationLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 454, 8) + __date._UseLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 454, 8) date = property(__date.value, __date.set, None, None) # Attribute timeStepSize uses Python identifier timeStepSize __timeStepSize = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'timeStepSize'), 'timeStepSize', '__AbsentNamespace0_CommonRoad_timeStepSize', pyxb.binding.datatypes.float) - __timeStepSize._DeclarationLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 368, 8) - __timeStepSize._UseLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 368, 8) + __timeStepSize._DeclarationLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 455, 8) + __timeStepSize._UseLocation = pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 455, 8) timeStepSize = property(__timeStepSize.value, __timeStepSize.set, None, None) @@ -1301,7 +1554,10 @@ class CommonRoad (pyxb.binding.basis.complexTypeDefinition): __egoVehicle.name() : __egoVehicle, __parkingLot.name() : __parkingLot, __trafficSign.name() : __trafficSign, - __intersection.name() : __intersection + __ramp.name() : __ramp, + __intersection.name() : __intersection, + __islandJunction.name() : __islandJunction, + __roadMarking.name() : __roadMarking }) _AttributeMap.update({ __commonRoadVersion.name() : __commonRoadVersion, @@ -1313,16 +1569,16 @@ class CommonRoad (pyxb.binding.basis.complexTypeDefinition): Namespace.addCategoryObject('typeBinding', 'CommonRoad', CommonRoad) -commonRoad = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'commonRoad'), CommonRoad, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 372, 4)) +commonRoad = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'commonRoad'), CommonRoad, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 459, 4)) Namespace.addCategoryObject('elementBinding', commonRoad.name().localName(), commonRoad) -floatInterval._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'exact'), pyxb.binding.datatypes.float, scope=floatInterval, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 21, 12))) +floatInterval._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'exact'), pyxb.binding.datatypes.float, scope=floatInterval, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 21, 12))) -floatInterval._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'intervalStart'), pyxb.binding.datatypes.float, scope=floatInterval, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 23, 16))) +floatInterval._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'intervalStart'), pyxb.binding.datatypes.float, scope=floatInterval, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 23, 16))) -floatInterval._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'intervalEnd'), pyxb.binding.datatypes.float, scope=floatInterval, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 24, 16))) +floatInterval._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'intervalEnd'), pyxb.binding.datatypes.float, scope=floatInterval, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 24, 16))) def _BuildAutomaton (): # Remove this helper function from the namespace after it is invoked @@ -1333,15 +1589,15 @@ def _BuildAutomaton (): counters = set() states = [] final_update = set() - symbol = pyxb.binding.content.ElementUse(floatInterval._UseForTag(pyxb.namespace.ExpandedName(None, 'exact')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 21, 12)) + symbol = pyxb.binding.content.ElementUse(floatInterval._UseForTag(pyxb.namespace.ExpandedName(None, 'exact')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 21, 12)) st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) states.append(st_0) final_update = None - symbol = pyxb.binding.content.ElementUse(floatInterval._UseForTag(pyxb.namespace.ExpandedName(None, 'intervalStart')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 23, 16)) + symbol = pyxb.binding.content.ElementUse(floatInterval._UseForTag(pyxb.namespace.ExpandedName(None, 'intervalStart')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 23, 16)) st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) states.append(st_1) final_update = set() - symbol = pyxb.binding.content.ElementUse(floatInterval._UseForTag(pyxb.namespace.ExpandedName(None, 'intervalEnd')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 24, 16)) + symbol = pyxb.binding.content.ElementUse(floatInterval._UseForTag(pyxb.namespace.ExpandedName(None, 'intervalEnd')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 24, 16)) st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) states.append(st_2) transitions = [] @@ -1358,9 +1614,9 @@ def _BuildAutomaton (): -point._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'x'), pyxb.binding.datatypes.float, scope=point, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 38, 12))) +point._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'x'), pyxb.binding.datatypes.float, scope=point, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 38, 12))) -point._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'y'), pyxb.binding.datatypes.float, scope=point, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 39, 12))) +point._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'y'), pyxb.binding.datatypes.float, scope=point, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 39, 12))) def _BuildAutomaton_ (): # Remove this helper function from the namespace after it is invoked @@ -1371,11 +1627,11 @@ def _BuildAutomaton_ (): counters = set() states = [] final_update = None - symbol = pyxb.binding.content.ElementUse(point._UseForTag(pyxb.namespace.ExpandedName(None, 'x')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 38, 12)) + symbol = pyxb.binding.content.ElementUse(point._UseForTag(pyxb.namespace.ExpandedName(None, 'x')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 38, 12)) st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) states.append(st_0) final_update = set() - symbol = pyxb.binding.content.ElementUse(point._UseForTag(pyxb.namespace.ExpandedName(None, 'y')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 39, 12)) + symbol = pyxb.binding.content.ElementUse(point._UseForTag(pyxb.namespace.ExpandedName(None, 'y')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 39, 12)) st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) states.append(st_1) transitions = [] @@ -1390,13 +1646,13 @@ def _BuildAutomaton_ (): -rectangle._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'length'), distance, scope=rectangle, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 57, 12))) +rectangle._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'length'), distance, scope=rectangle, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 57, 12))) -rectangle._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'width'), distance, scope=rectangle, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 58, 12))) +rectangle._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'width'), distance, scope=rectangle, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 58, 12))) -rectangle._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'orientation'), pyxb.binding.datatypes.float, scope=rectangle, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 59, 12))) +rectangle._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'orientation'), pyxb.binding.datatypes.float, scope=rectangle, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 59, 12))) -rectangle._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'centerPoint'), point, scope=rectangle, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 60, 12))) +rectangle._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'centerPoint'), point, scope=rectangle, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 60, 12))) def _BuildAutomaton_2 (): # Remove this helper function from the namespace after it is invoked @@ -1407,19 +1663,19 @@ def _BuildAutomaton_2 (): counters = set() states = [] final_update = None - symbol = pyxb.binding.content.ElementUse(rectangle._UseForTag(pyxb.namespace.ExpandedName(None, 'length')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 57, 12)) + symbol = pyxb.binding.content.ElementUse(rectangle._UseForTag(pyxb.namespace.ExpandedName(None, 'length')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 57, 12)) st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) states.append(st_0) final_update = None - symbol = pyxb.binding.content.ElementUse(rectangle._UseForTag(pyxb.namespace.ExpandedName(None, 'width')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 58, 12)) + symbol = pyxb.binding.content.ElementUse(rectangle._UseForTag(pyxb.namespace.ExpandedName(None, 'width')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 58, 12)) st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) states.append(st_1) final_update = None - symbol = pyxb.binding.content.ElementUse(rectangle._UseForTag(pyxb.namespace.ExpandedName(None, 'orientation')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 59, 12)) + symbol = pyxb.binding.content.ElementUse(rectangle._UseForTag(pyxb.namespace.ExpandedName(None, 'orientation')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 59, 12)) st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) states.append(st_2) final_update = set() - symbol = pyxb.binding.content.ElementUse(rectangle._UseForTag(pyxb.namespace.ExpandedName(None, 'centerPoint')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 60, 12)) + symbol = pyxb.binding.content.ElementUse(rectangle._UseForTag(pyxb.namespace.ExpandedName(None, 'centerPoint')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 60, 12)) st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) states.append(st_3) transitions = [] @@ -1442,9 +1698,9 @@ def _BuildAutomaton_2 (): -circle._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'radius'), distance, scope=circle, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 76, 12))) +circle._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'radius'), distance, scope=circle, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 76, 12))) -circle._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'centerPoint'), point, scope=circle, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 77, 12))) +circle._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'centerPoint'), point, scope=circle, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 77, 12))) def _BuildAutomaton_3 (): # Remove this helper function from the namespace after it is invoked @@ -1455,11 +1711,11 @@ def _BuildAutomaton_3 (): counters = set() states = [] final_update = None - symbol = pyxb.binding.content.ElementUse(circle._UseForTag(pyxb.namespace.ExpandedName(None, 'radius')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 76, 12)) + symbol = pyxb.binding.content.ElementUse(circle._UseForTag(pyxb.namespace.ExpandedName(None, 'radius')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 76, 12)) st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) states.append(st_0) final_update = set() - symbol = pyxb.binding.content.ElementUse(circle._UseForTag(pyxb.namespace.ExpandedName(None, 'centerPoint')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 77, 12)) + symbol = pyxb.binding.content.ElementUse(circle._UseForTag(pyxb.namespace.ExpandedName(None, 'centerPoint')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 77, 12)) st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) states.append(st_1) transitions = [] @@ -1474,7 +1730,7 @@ def _BuildAutomaton_3 (): -polygon._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'point'), point, scope=polygon, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 101, 12))) +polygon._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'point'), point, scope=polygon, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 101, 12))) def _BuildAutomaton_4 (): # Remove this helper function from the namespace after it is invoked @@ -1483,12 +1739,12 @@ def _BuildAutomaton_4 (): import pyxb.utils.fac as fac counters = set() - cc_0 = fac.CounterCondition(min=3, max=None, metadata=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 101, 12)) + cc_0 = fac.CounterCondition(min=3, max=None, metadata=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 101, 12)) counters.add(cc_0) states = [] final_update = set() final_update.add(fac.UpdateInstruction(cc_0, False)) - symbol = pyxb.binding.content.ElementUse(polygon._UseForTag(pyxb.namespace.ExpandedName(None, 'point')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 101, 12)) + symbol = pyxb.binding.content.ElementUse(polygon._UseForTag(pyxb.namespace.ExpandedName(None, 'point')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 101, 12)) st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) states.append(st_0) transitions = [] @@ -1501,11 +1757,11 @@ def _BuildAutomaton_4 (): -shape._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'rectangle'), rectangle, scope=shape, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 119, 12))) +shape._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'rectangle'), rectangle, scope=shape, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 119, 12))) -shape._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'circle'), circle, scope=shape, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 120, 12))) +shape._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'circle'), circle, scope=shape, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 120, 12))) -shape._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'polygon'), polygon, scope=shape, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 121, 12))) +shape._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'polygon'), polygon, scope=shape, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 121, 12))) def _BuildAutomaton_5 (): # Remove this helper function from the namespace after it is invoked @@ -1516,15 +1772,15 @@ def _BuildAutomaton_5 (): counters = set() states = [] final_update = set() - symbol = pyxb.binding.content.ElementUse(shape._UseForTag(pyxb.namespace.ExpandedName(None, 'rectangle')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 119, 12)) + symbol = pyxb.binding.content.ElementUse(shape._UseForTag(pyxb.namespace.ExpandedName(None, 'rectangle')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 119, 12)) st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) states.append(st_0) final_update = set() - symbol = pyxb.binding.content.ElementUse(shape._UseForTag(pyxb.namespace.ExpandedName(None, 'circle')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 120, 12)) + symbol = pyxb.binding.content.ElementUse(shape._UseForTag(pyxb.namespace.ExpandedName(None, 'circle')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 120, 12)) st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) states.append(st_1) final_update = set() - symbol = pyxb.binding.content.ElementUse(shape._UseForTag(pyxb.namespace.ExpandedName(None, 'polygon')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 121, 12)) + symbol = pyxb.binding.content.ElementUse(shape._UseForTag(pyxb.namespace.ExpandedName(None, 'polygon')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 121, 12)) st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) states.append(st_2) transitions = [] @@ -1557,9 +1813,9 @@ def _BuildAutomaton_5 (): -occupancy._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'shape'), shape, scope=occupancy, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 127, 12))) +occupancy._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'shape'), shape, scope=occupancy, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 127, 12))) -occupancy._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'time'), floatInterval, scope=occupancy, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 128, 12))) +occupancy._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'time'), floatInterval, scope=occupancy, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 128, 12))) def _BuildAutomaton_6 (): # Remove this helper function from the namespace after it is invoked @@ -1570,11 +1826,11 @@ def _BuildAutomaton_6 (): counters = set() states = [] final_update = None - symbol = pyxb.binding.content.ElementUse(occupancy._UseForTag(pyxb.namespace.ExpandedName(None, 'shape')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 127, 12)) + symbol = pyxb.binding.content.ElementUse(occupancy._UseForTag(pyxb.namespace.ExpandedName(None, 'shape')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 127, 12)) st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) states.append(st_0) final_update = set() - symbol = pyxb.binding.content.ElementUse(occupancy._UseForTag(pyxb.namespace.ExpandedName(None, 'time')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 128, 12)) + symbol = pyxb.binding.content.ElementUse(occupancy._UseForTag(pyxb.namespace.ExpandedName(None, 'time')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 128, 12)) st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) states.append(st_1) transitions = [] @@ -1589,15 +1845,15 @@ def _BuildAutomaton_6 (): -state._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'position'), CTD_ANON, scope=state, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 134, 12))) +state._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'position'), CTD_ANON, scope=state, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 134, 12))) -state._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'orientation'), floatInterval, scope=state, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 146, 12))) +state._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'orientation'), floatInterval, scope=state, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 146, 12))) -state._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'time'), floatInterval, scope=state, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 147, 12))) +state._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'time'), floatInterval, scope=state, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 147, 12))) -state._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'velocity'), floatInterval, scope=state, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 148, 12))) +state._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'velocity'), floatInterval, scope=state, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 148, 12))) -state._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'acceleration'), floatInterval, scope=state, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 149, 12))) +state._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'acceleration'), floatInterval, scope=state, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 149, 12))) def _BuildAutomaton_7 (): # Remove this helper function from the namespace after it is invoked @@ -1606,31 +1862,31 @@ def _BuildAutomaton_7 (): import pyxb.utils.fac as fac counters = set() - cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 148, 12)) + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 148, 12)) counters.add(cc_0) - cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 149, 12)) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 149, 12)) counters.add(cc_1) states = [] final_update = None - symbol = pyxb.binding.content.ElementUse(state._UseForTag(pyxb.namespace.ExpandedName(None, 'position')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 134, 12)) + symbol = pyxb.binding.content.ElementUse(state._UseForTag(pyxb.namespace.ExpandedName(None, 'position')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 134, 12)) st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) states.append(st_0) final_update = None - symbol = pyxb.binding.content.ElementUse(state._UseForTag(pyxb.namespace.ExpandedName(None, 'orientation')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 146, 12)) + symbol = pyxb.binding.content.ElementUse(state._UseForTag(pyxb.namespace.ExpandedName(None, 'orientation')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 146, 12)) st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) states.append(st_1) final_update = set() - symbol = pyxb.binding.content.ElementUse(state._UseForTag(pyxb.namespace.ExpandedName(None, 'time')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 147, 12)) + symbol = pyxb.binding.content.ElementUse(state._UseForTag(pyxb.namespace.ExpandedName(None, 'time')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 147, 12)) st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) states.append(st_2) final_update = set() final_update.add(fac.UpdateInstruction(cc_0, False)) - symbol = pyxb.binding.content.ElementUse(state._UseForTag(pyxb.namespace.ExpandedName(None, 'velocity')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 148, 12)) + symbol = pyxb.binding.content.ElementUse(state._UseForTag(pyxb.namespace.ExpandedName(None, 'velocity')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 148, 12)) st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) states.append(st_3) final_update = set() final_update.add(fac.UpdateInstruction(cc_1, False)) - symbol = pyxb.binding.content.ElementUse(state._UseForTag(pyxb.namespace.ExpandedName(None, 'acceleration')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 149, 12)) + symbol = pyxb.binding.content.ElementUse(state._UseForTag(pyxb.namespace.ExpandedName(None, 'acceleration')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 149, 12)) st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) states.append(st_4) transitions = [] @@ -1663,13 +1919,13 @@ def _BuildAutomaton_7 (): -CTD_ANON._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'point'), point, scope=CTD_ANON, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 137, 24))) +CTD_ANON._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'point'), point, scope=CTD_ANON, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 137, 24))) -CTD_ANON._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'rectangle'), rectangle, scope=CTD_ANON, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 139, 28))) +CTD_ANON._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'rectangle'), rectangle, scope=CTD_ANON, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 139, 28))) -CTD_ANON._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'circle'), circle, scope=CTD_ANON, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 140, 28))) +CTD_ANON._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'circle'), circle, scope=CTD_ANON, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 140, 28))) -CTD_ANON._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'polygon'), polygon, scope=CTD_ANON, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 141, 28))) +CTD_ANON._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'polygon'), polygon, scope=CTD_ANON, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 141, 28))) def _BuildAutomaton_8 (): # Remove this helper function from the namespace after it is invoked @@ -1680,19 +1936,19 @@ def _BuildAutomaton_8 (): counters = set() states = [] final_update = set() - symbol = pyxb.binding.content.ElementUse(CTD_ANON._UseForTag(pyxb.namespace.ExpandedName(None, 'point')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 137, 24)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON._UseForTag(pyxb.namespace.ExpandedName(None, 'point')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 137, 24)) st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) states.append(st_0) final_update = set() - symbol = pyxb.binding.content.ElementUse(CTD_ANON._UseForTag(pyxb.namespace.ExpandedName(None, 'rectangle')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 139, 28)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON._UseForTag(pyxb.namespace.ExpandedName(None, 'rectangle')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 139, 28)) st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) states.append(st_1) final_update = set() - symbol = pyxb.binding.content.ElementUse(CTD_ANON._UseForTag(pyxb.namespace.ExpandedName(None, 'circle')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 140, 28)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON._UseForTag(pyxb.namespace.ExpandedName(None, 'circle')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 140, 28)) st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) states.append(st_2) final_update = set() - symbol = pyxb.binding.content.ElementUse(CTD_ANON._UseForTag(pyxb.namespace.ExpandedName(None, 'polygon')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 141, 28)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON._UseForTag(pyxb.namespace.ExpandedName(None, 'polygon')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 141, 28)) st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) states.append(st_3) transitions = [] @@ -1727,15 +1983,15 @@ def _BuildAutomaton_8 (): -obstacle._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'role'), obstacleRole, scope=obstacle, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 181, 12))) +obstacle._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'role'), obstacleRole, scope=obstacle, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 182, 12))) -obstacle._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'type'), obstacleType, scope=obstacle, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 182, 12))) +obstacle._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'type'), obstacleType, scope=obstacle, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 183, 12))) -obstacle._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'shape'), shape, scope=obstacle, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 183, 12))) +obstacle._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'shape'), shape, scope=obstacle, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 184, 12))) -obstacle._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'trajectory'), CTD_ANON_, scope=obstacle, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 185, 16))) +obstacle._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'trajectory'), CTD_ANON_, scope=obstacle, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 186, 16))) -obstacle._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'occupancySet'), CTD_ANON_2, scope=obstacle, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 193, 16))) +obstacle._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'occupancySet'), CTD_ANON_2, scope=obstacle, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 194, 16))) def _BuildAutomaton_9 (): # Remove this helper function from the namespace after it is invoked @@ -1744,29 +2000,29 @@ def _BuildAutomaton_9 (): import pyxb.utils.fac as fac counters = set() - cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 184, 12)) + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 185, 12)) counters.add(cc_0) states = [] final_update = None - symbol = pyxb.binding.content.ElementUse(obstacle._UseForTag(pyxb.namespace.ExpandedName(None, 'role')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 181, 12)) + symbol = pyxb.binding.content.ElementUse(obstacle._UseForTag(pyxb.namespace.ExpandedName(None, 'role')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 182, 12)) st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) states.append(st_0) final_update = None - symbol = pyxb.binding.content.ElementUse(obstacle._UseForTag(pyxb.namespace.ExpandedName(None, 'type')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 182, 12)) + symbol = pyxb.binding.content.ElementUse(obstacle._UseForTag(pyxb.namespace.ExpandedName(None, 'type')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 183, 12)) st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) states.append(st_1) final_update = set() - symbol = pyxb.binding.content.ElementUse(obstacle._UseForTag(pyxb.namespace.ExpandedName(None, 'shape')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 183, 12)) + symbol = pyxb.binding.content.ElementUse(obstacle._UseForTag(pyxb.namespace.ExpandedName(None, 'shape')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 184, 12)) st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) states.append(st_2) final_update = set() final_update.add(fac.UpdateInstruction(cc_0, False)) - symbol = pyxb.binding.content.ElementUse(obstacle._UseForTag(pyxb.namespace.ExpandedName(None, 'trajectory')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 185, 16)) + symbol = pyxb.binding.content.ElementUse(obstacle._UseForTag(pyxb.namespace.ExpandedName(None, 'trajectory')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 186, 16)) st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) states.append(st_3) final_update = set() final_update.add(fac.UpdateInstruction(cc_0, False)) - symbol = pyxb.binding.content.ElementUse(obstacle._UseForTag(pyxb.namespace.ExpandedName(None, 'occupancySet')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 193, 16)) + symbol = pyxb.binding.content.ElementUse(obstacle._UseForTag(pyxb.namespace.ExpandedName(None, 'occupancySet')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 194, 16)) st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) states.append(st_4) transitions = [] @@ -1801,7 +2057,7 @@ def _BuildAutomaton_9 (): -CTD_ANON_._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'state'), state, scope=CTD_ANON_, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 188, 28))) +CTD_ANON_._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'state'), state, scope=CTD_ANON_, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 189, 28))) def _BuildAutomaton_10 (): # Remove this helper function from the namespace after it is invoked @@ -1812,7 +2068,7 @@ def _BuildAutomaton_10 (): counters = set() states = [] final_update = set() - symbol = pyxb.binding.content.ElementUse(CTD_ANON_._UseForTag(pyxb.namespace.ExpandedName(None, 'state')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 188, 28)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_._UseForTag(pyxb.namespace.ExpandedName(None, 'state')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 189, 28)) st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) states.append(st_0) transitions = [] @@ -1825,7 +2081,7 @@ def _BuildAutomaton_10 (): -CTD_ANON_2._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'occupancy'), occupancy, scope=CTD_ANON_2, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 196, 28))) +CTD_ANON_2._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'occupancy'), occupancy, scope=CTD_ANON_2, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 197, 28))) def _BuildAutomaton_11 (): # Remove this helper function from the namespace after it is invoked @@ -1836,7 +2092,7 @@ def _BuildAutomaton_11 (): counters = set() states = [] final_update = set() - symbol = pyxb.binding.content.ElementUse(CTD_ANON_2._UseForTag(pyxb.namespace.ExpandedName(None, 'occupancy')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 196, 28)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_2._UseForTag(pyxb.namespace.ExpandedName(None, 'occupancy')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 197, 28)) st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) states.append(st_0) transitions = [] @@ -1849,9 +2105,9 @@ def _BuildAutomaton_11 (): -boundary._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'point'), point, scope=boundary, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 215, 12))) +boundary._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'point'), point, scope=boundary, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 216, 12))) -boundary._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'lineMarking'), lineMarking, scope=boundary, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 217, 12))) +boundary._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'lineMarking'), lineMarking, scope=boundary, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 218, 12))) def _BuildAutomaton_12 (): # Remove this helper function from the namespace after it is invoked @@ -1860,16 +2116,16 @@ def _BuildAutomaton_12 (): import pyxb.utils.fac as fac counters = set() - cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 217, 12)) + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 218, 12)) counters.add(cc_0) states = [] final_update = set() - symbol = pyxb.binding.content.ElementUse(boundary._UseForTag(pyxb.namespace.ExpandedName(None, 'point')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 215, 12)) + symbol = pyxb.binding.content.ElementUse(boundary._UseForTag(pyxb.namespace.ExpandedName(None, 'point')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 216, 12)) st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) states.append(st_0) final_update = set() final_update.add(fac.UpdateInstruction(cc_0, False)) - symbol = pyxb.binding.content.ElementUse(boundary._UseForTag(pyxb.namespace.ExpandedName(None, 'lineMarking')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 217, 12)) + symbol = pyxb.binding.content.ElementUse(boundary._UseForTag(pyxb.namespace.ExpandedName(None, 'lineMarking')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 218, 12)) st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) states.append(st_1) transitions = [] @@ -1888,7 +2144,11 @@ def _BuildAutomaton_12 (): -laneletRefList._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'lanelet'), laneletRef, scope=laneletRefList, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 229, 12))) +lineMarkingAttributes._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'lineWidth'), pyxb.binding.datatypes.float, scope=lineMarkingAttributes, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 225, 12))) + +lineMarkingAttributes._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'segmentLength'), pyxb.binding.datatypes.float, scope=lineMarkingAttributes, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 226, 12))) + +lineMarkingAttributes._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'segmentGap'), pyxb.binding.datatypes.float, scope=lineMarkingAttributes, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 227, 12))) def _BuildAutomaton_13 (): # Remove this helper function from the namespace after it is invoked @@ -1897,12 +2157,50 @@ def _BuildAutomaton_13 (): import pyxb.utils.fac as fac counters = set() - cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 229, 12)) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(lineMarkingAttributes._UseForTag(pyxb.namespace.ExpandedName(None, 'lineWidth')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 225, 12)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(lineMarkingAttributes._UseForTag(pyxb.namespace.ExpandedName(None, 'segmentLength')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 226, 12)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + symbol = pyxb.binding.content.ElementUse(lineMarkingAttributes._UseForTag(pyxb.namespace.ExpandedName(None, 'segmentGap')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 227, 12)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + st_2._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +lineMarkingAttributes._Automaton = _BuildAutomaton_13() + + + + +laneletRefList._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'lanelet'), laneletRef, scope=laneletRefList, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 239, 12))) + +def _BuildAutomaton_14 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_14 + del _BuildAutomaton_14 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 239, 12)) counters.add(cc_0) states = [] final_update = set() final_update.add(fac.UpdateInstruction(cc_0, False)) - symbol = pyxb.binding.content.ElementUse(laneletRefList._UseForTag(pyxb.namespace.ExpandedName(None, 'lanelet')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 229, 12)) + symbol = pyxb.binding.content.ElementUse(laneletRefList._UseForTag(pyxb.namespace.ExpandedName(None, 'lanelet')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 239, 12)) st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) states.append(st_0) transitions = [] @@ -1910,92 +2208,101 @@ def _BuildAutomaton_13 (): fac.UpdateInstruction(cc_0, True) ])) st_0._set_transitionSet(transitions) return fac.Automaton(states, counters, True, containing_state=None) -laneletRefList._Automaton = _BuildAutomaton_13() +laneletRefList._Automaton = _BuildAutomaton_14() -lanelet._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'type'), laneletType, scope=lanelet, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 257, 12), unicode_default='road')) +lanelet._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'type'), laneletType, scope=lanelet, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 267, 12), unicode_default='road')) -lanelet._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'isStart'), pyxb.binding.datatypes.boolean, scope=lanelet, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 258, 12))) +lanelet._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'isStart'), pyxb.binding.datatypes.boolean, scope=lanelet, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 268, 12))) -lanelet._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'leftBoundary'), boundary, scope=lanelet, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 259, 12))) +lanelet._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'leftBoundary'), boundary, scope=lanelet, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 269, 12))) -lanelet._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'rightBoundary'), boundary, scope=lanelet, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 260, 12))) +lanelet._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'rightBoundary'), boundary, scope=lanelet, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 270, 12))) -lanelet._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'predecessor'), laneletRefList, scope=lanelet, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 261, 12))) +lanelet._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'predecessor'), laneletRefList, scope=lanelet, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 271, 12))) -lanelet._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'successor'), laneletRefList, scope=lanelet, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 263, 12))) +lanelet._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'successor'), laneletRefList, scope=lanelet, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 273, 12))) -lanelet._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'adjacentLeft'), laneletAdjacentRef, scope=lanelet, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 265, 12))) +lanelet._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'adjacentLeft'), laneletAdjacentRef, scope=lanelet, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 275, 12))) -lanelet._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'adjacentRight'), laneletAdjacentRef, scope=lanelet, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 267, 12))) +lanelet._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'adjacentRight'), laneletAdjacentRef, scope=lanelet, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 277, 12))) -lanelet._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'stopLine'), lineMarking, scope=lanelet, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 270, 12))) +lanelet._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'stopLine'), lineMarking, scope=lanelet, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 280, 12))) -def _BuildAutomaton_14 (): +lanelet._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'stopLineAttributes'), lineMarkingAttributes, scope=lanelet, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 281, 12))) + +def _BuildAutomaton_15 (): # Remove this helper function from the namespace after it is invoked - global _BuildAutomaton_14 - del _BuildAutomaton_14 + global _BuildAutomaton_15 + del _BuildAutomaton_15 import pyxb.utils.fac as fac counters = set() - cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 257, 12)) + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 267, 12)) counters.add(cc_0) - cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 258, 12)) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 268, 12)) counters.add(cc_1) - cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 261, 12)) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 271, 12)) counters.add(cc_2) - cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 263, 12)) + cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 273, 12)) counters.add(cc_3) - cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 265, 12)) + cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 275, 12)) counters.add(cc_4) - cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 267, 12)) + cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 277, 12)) counters.add(cc_5) - cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 270, 12)) + cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 280, 12)) counters.add(cc_6) + cc_7 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 281, 12)) + counters.add(cc_7) states = [] final_update = None - symbol = pyxb.binding.content.ElementUse(lanelet._UseForTag(pyxb.namespace.ExpandedName(None, 'type')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 257, 12)) + symbol = pyxb.binding.content.ElementUse(lanelet._UseForTag(pyxb.namespace.ExpandedName(None, 'type')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 267, 12)) st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) states.append(st_0) final_update = None - symbol = pyxb.binding.content.ElementUse(lanelet._UseForTag(pyxb.namespace.ExpandedName(None, 'isStart')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 258, 12)) + symbol = pyxb.binding.content.ElementUse(lanelet._UseForTag(pyxb.namespace.ExpandedName(None, 'isStart')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 268, 12)) st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) states.append(st_1) final_update = None - symbol = pyxb.binding.content.ElementUse(lanelet._UseForTag(pyxb.namespace.ExpandedName(None, 'leftBoundary')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 259, 12)) + symbol = pyxb.binding.content.ElementUse(lanelet._UseForTag(pyxb.namespace.ExpandedName(None, 'leftBoundary')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 269, 12)) st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) states.append(st_2) final_update = set() - symbol = pyxb.binding.content.ElementUse(lanelet._UseForTag(pyxb.namespace.ExpandedName(None, 'rightBoundary')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 260, 12)) + symbol = pyxb.binding.content.ElementUse(lanelet._UseForTag(pyxb.namespace.ExpandedName(None, 'rightBoundary')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 270, 12)) st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) states.append(st_3) final_update = set() final_update.add(fac.UpdateInstruction(cc_2, False)) - symbol = pyxb.binding.content.ElementUse(lanelet._UseForTag(pyxb.namespace.ExpandedName(None, 'predecessor')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 261, 12)) + symbol = pyxb.binding.content.ElementUse(lanelet._UseForTag(pyxb.namespace.ExpandedName(None, 'predecessor')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 271, 12)) st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) states.append(st_4) final_update = set() final_update.add(fac.UpdateInstruction(cc_3, False)) - symbol = pyxb.binding.content.ElementUse(lanelet._UseForTag(pyxb.namespace.ExpandedName(None, 'successor')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 263, 12)) + symbol = pyxb.binding.content.ElementUse(lanelet._UseForTag(pyxb.namespace.ExpandedName(None, 'successor')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 273, 12)) st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) states.append(st_5) final_update = set() final_update.add(fac.UpdateInstruction(cc_4, False)) - symbol = pyxb.binding.content.ElementUse(lanelet._UseForTag(pyxb.namespace.ExpandedName(None, 'adjacentLeft')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 265, 12)) + symbol = pyxb.binding.content.ElementUse(lanelet._UseForTag(pyxb.namespace.ExpandedName(None, 'adjacentLeft')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 275, 12)) st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) states.append(st_6) final_update = set() final_update.add(fac.UpdateInstruction(cc_5, False)) - symbol = pyxb.binding.content.ElementUse(lanelet._UseForTag(pyxb.namespace.ExpandedName(None, 'adjacentRight')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 267, 12)) + symbol = pyxb.binding.content.ElementUse(lanelet._UseForTag(pyxb.namespace.ExpandedName(None, 'adjacentRight')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 277, 12)) st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) states.append(st_7) final_update = set() final_update.add(fac.UpdateInstruction(cc_6, False)) - symbol = pyxb.binding.content.ElementUse(lanelet._UseForTag(pyxb.namespace.ExpandedName(None, 'stopLine')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 270, 12)) + symbol = pyxb.binding.content.ElementUse(lanelet._UseForTag(pyxb.namespace.ExpandedName(None, 'stopLine')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 280, 12)) st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) states.append(st_8) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_7, False)) + symbol = pyxb.binding.content.ElementUse(lanelet._UseForTag(pyxb.namespace.ExpandedName(None, 'stopLineAttributes')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 281, 12)) + st_9 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_9) transitions = [] transitions.append(fac.Transition(st_0, [ fac.UpdateInstruction(cc_0, True) ])) @@ -2025,6 +2332,8 @@ def _BuildAutomaton_14 (): ])) transitions.append(fac.Transition(st_8, [ ])) + transitions.append(fac.Transition(st_9, [ + ])) st_3._set_transitionSet(transitions) transitions = [] transitions.append(fac.Transition(st_4, [ @@ -2037,6 +2346,8 @@ def _BuildAutomaton_14 (): fac.UpdateInstruction(cc_2, False) ])) transitions.append(fac.Transition(st_8, [ fac.UpdateInstruction(cc_2, False) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_2, False) ])) st_4._set_transitionSet(transitions) transitions = [] transitions.append(fac.Transition(st_5, [ @@ -2047,6 +2358,8 @@ def _BuildAutomaton_14 (): fac.UpdateInstruction(cc_3, False) ])) transitions.append(fac.Transition(st_8, [ fac.UpdateInstruction(cc_3, False) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_3, False) ])) st_5._set_transitionSet(transitions) transitions = [] transitions.append(fac.Transition(st_6, [ @@ -2055,53 +2368,63 @@ def _BuildAutomaton_14 (): fac.UpdateInstruction(cc_4, False) ])) transitions.append(fac.Transition(st_8, [ fac.UpdateInstruction(cc_4, False) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_4, False) ])) st_6._set_transitionSet(transitions) transitions = [] transitions.append(fac.Transition(st_7, [ fac.UpdateInstruction(cc_5, True) ])) transitions.append(fac.Transition(st_8, [ fac.UpdateInstruction(cc_5, False) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_5, False) ])) st_7._set_transitionSet(transitions) transitions = [] transitions.append(fac.Transition(st_8, [ fac.UpdateInstruction(cc_6, True) ])) + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_6, False) ])) st_8._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_9, [ + fac.UpdateInstruction(cc_7, True) ])) + st_9._set_transitionSet(transitions) return fac.Automaton(states, counters, False, containing_state=None) -lanelet._Automaton = _BuildAutomaton_14() +lanelet._Automaton = _BuildAutomaton_15() -egoVehicle._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'type'), obstacleType, scope=egoVehicle, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 277, 12))) +egoVehicle._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'type'), obstacleType, scope=egoVehicle, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 288, 12))) -egoVehicle._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'shape'), shape, scope=egoVehicle, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 278, 12))) +egoVehicle._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'shape'), shape, scope=egoVehicle, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 289, 12))) -egoVehicle._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'initialState'), state, scope=egoVehicle, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 279, 12))) +egoVehicle._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'initialState'), state, scope=egoVehicle, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 290, 12))) -egoVehicle._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'goalRegion'), CTD_ANON_3, scope=egoVehicle, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 280, 12))) +egoVehicle._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'goalRegion'), CTD_ANON_3, scope=egoVehicle, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 291, 12))) -def _BuildAutomaton_15 (): +def _BuildAutomaton_16 (): # Remove this helper function from the namespace after it is invoked - global _BuildAutomaton_15 - del _BuildAutomaton_15 + global _BuildAutomaton_16 + del _BuildAutomaton_16 import pyxb.utils.fac as fac counters = set() states = [] final_update = None - symbol = pyxb.binding.content.ElementUse(egoVehicle._UseForTag(pyxb.namespace.ExpandedName(None, 'type')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 277, 12)) + symbol = pyxb.binding.content.ElementUse(egoVehicle._UseForTag(pyxb.namespace.ExpandedName(None, 'type')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 288, 12)) st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) states.append(st_0) final_update = None - symbol = pyxb.binding.content.ElementUse(egoVehicle._UseForTag(pyxb.namespace.ExpandedName(None, 'shape')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 278, 12)) + symbol = pyxb.binding.content.ElementUse(egoVehicle._UseForTag(pyxb.namespace.ExpandedName(None, 'shape')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 289, 12)) st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) states.append(st_1) final_update = None - symbol = pyxb.binding.content.ElementUse(egoVehicle._UseForTag(pyxb.namespace.ExpandedName(None, 'initialState')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 279, 12)) + symbol = pyxb.binding.content.ElementUse(egoVehicle._UseForTag(pyxb.namespace.ExpandedName(None, 'initialState')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 290, 12)) st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) states.append(st_2) final_update = set() - symbol = pyxb.binding.content.ElementUse(egoVehicle._UseForTag(pyxb.namespace.ExpandedName(None, 'goalRegion')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 280, 12)) + symbol = pyxb.binding.content.ElementUse(egoVehicle._UseForTag(pyxb.namespace.ExpandedName(None, 'goalRegion')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 291, 12)) st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) states.append(st_3) transitions = [] @@ -2119,23 +2442,23 @@ def _BuildAutomaton_15 (): transitions = [] st_3._set_transitionSet(transitions) return fac.Automaton(states, counters, False, containing_state=None) -egoVehicle._Automaton = _BuildAutomaton_15() +egoVehicle._Automaton = _BuildAutomaton_16() -CTD_ANON_3._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'state'), state, scope=CTD_ANON_3, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 283, 24))) +CTD_ANON_3._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'state'), state, scope=CTD_ANON_3, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 294, 24))) -def _BuildAutomaton_16 (): +def _BuildAutomaton_17 (): # Remove this helper function from the namespace after it is invoked - global _BuildAutomaton_16 - del _BuildAutomaton_16 + global _BuildAutomaton_17 + del _BuildAutomaton_17 import pyxb.utils.fac as fac counters = set() states = [] final_update = set() - symbol = pyxb.binding.content.ElementUse(CTD_ANON_3._UseForTag(pyxb.namespace.ExpandedName(None, 'state')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 283, 24)) + symbol = pyxb.binding.content.ElementUse(CTD_ANON_3._UseForTag(pyxb.namespace.ExpandedName(None, 'state')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 294, 24)) st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) states.append(st_0) transitions = [] @@ -2143,57 +2466,81 @@ def _BuildAutomaton_16 (): ])) st_0._set_transitionSet(transitions) return fac.Automaton(states, counters, False, containing_state=None) -CTD_ANON_3._Automaton = _BuildAutomaton_16() +CTD_ANON_3._Automaton = _BuildAutomaton_17() -parkingLot._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'shape'), shape, scope=parkingLot, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 295, 12))) +parkingLot._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'shape'), shape, scope=parkingLot, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 306, 12))) -def _BuildAutomaton_17 (): +def _BuildAutomaton_18 (): # Remove this helper function from the namespace after it is invoked - global _BuildAutomaton_17 - del _BuildAutomaton_17 + global _BuildAutomaton_18 + del _BuildAutomaton_18 import pyxb.utils.fac as fac counters = set() states = [] final_update = set() - symbol = pyxb.binding.content.ElementUse(parkingLot._UseForTag(pyxb.namespace.ExpandedName(None, 'shape')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 295, 12)) + symbol = pyxb.binding.content.ElementUse(parkingLot._UseForTag(pyxb.namespace.ExpandedName(None, 'shape')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 306, 12)) st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) states.append(st_0) transitions = [] st_0._set_transitionSet(transitions) return fac.Automaton(states, counters, False, containing_state=None) -parkingLot._Automaton = _BuildAutomaton_17() +parkingLot._Automaton = _BuildAutomaton_18() -trafficSign._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'type'), STD_ANON, scope=trafficSign, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 303, 12))) +trafficIslandJunction._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'point'), point, scope=trafficIslandJunction, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 313, 12))) -trafficSign._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'orientation'), pyxb.binding.datatypes.float, scope=trafficSign, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 324, 12))) +def _BuildAutomaton_19 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_19 + del _BuildAutomaton_19 + import pyxb.utils.fac as fac -trafficSign._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'centerPoint'), point, scope=trafficSign, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 325, 12))) + counters = set() + states = [] + final_update = set() + symbol = pyxb.binding.content.ElementUse(trafficIslandJunction._UseForTag(pyxb.namespace.ExpandedName(None, 'point')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 313, 12)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + transitions = [] + transitions.append(fac.Transition(st_0, [ + ])) + st_0._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +trafficIslandJunction._Automaton = _BuildAutomaton_19() -def _BuildAutomaton_18 (): + + + +roadMarking._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'type'), roadMarkingType, scope=roadMarking, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 344, 12))) + +roadMarking._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'orientation'), pyxb.binding.datatypes.float, scope=roadMarking, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 345, 12))) + +roadMarking._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'centerPoint'), point, scope=roadMarking, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 346, 12))) + +def _BuildAutomaton_20 (): # Remove this helper function from the namespace after it is invoked - global _BuildAutomaton_18 - del _BuildAutomaton_18 + global _BuildAutomaton_20 + del _BuildAutomaton_20 import pyxb.utils.fac as fac counters = set() states = [] final_update = None - symbol = pyxb.binding.content.ElementUse(trafficSign._UseForTag(pyxb.namespace.ExpandedName(None, 'type')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 303, 12)) + symbol = pyxb.binding.content.ElementUse(roadMarking._UseForTag(pyxb.namespace.ExpandedName(None, 'type')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 344, 12)) st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) states.append(st_0) final_update = None - symbol = pyxb.binding.content.ElementUse(trafficSign._UseForTag(pyxb.namespace.ExpandedName(None, 'orientation')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 324, 12)) + symbol = pyxb.binding.content.ElementUse(roadMarking._UseForTag(pyxb.namespace.ExpandedName(None, 'orientation')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 345, 12)) st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) states.append(st_1) final_update = set() - symbol = pyxb.binding.content.ElementUse(trafficSign._UseForTag(pyxb.namespace.ExpandedName(None, 'centerPoint')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 325, 12)) + symbol = pyxb.binding.content.ElementUse(roadMarking._UseForTag(pyxb.namespace.ExpandedName(None, 'centerPoint')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 346, 12)) st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) states.append(st_2) transitions = [] @@ -2207,29 +2554,103 @@ def _BuildAutomaton_18 (): transitions = [] st_2._set_transitionSet(transitions) return fac.Automaton(states, counters, False, containing_state=None) -trafficSign._Automaton = _BuildAutomaton_18() +roadMarking._Automaton = _BuildAutomaton_20() -intersection._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'composition'), laneletRefList, scope=intersection, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 333, 12))) +trafficSign._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'type'), STD_ANON, scope=trafficSign, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 354, 12))) -intersection._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'priority'), CTD_ANON_4, scope=intersection, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 334, 12))) +trafficSign._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'orientation'), pyxb.binding.datatypes.float, scope=trafficSign, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 397, 12))) -def _BuildAutomaton_19 (): +trafficSign._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'centerPoint'), point, scope=trafficSign, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 398, 12))) + +def _BuildAutomaton_21 (): # Remove this helper function from the namespace after it is invoked - global _BuildAutomaton_19 - del _BuildAutomaton_19 + global _BuildAutomaton_21 + del _BuildAutomaton_21 + import pyxb.utils.fac as fac + + counters = set() + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(trafficSign._UseForTag(pyxb.namespace.ExpandedName(None, 'type')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 354, 12)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(trafficSign._UseForTag(pyxb.namespace.ExpandedName(None, 'orientation')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 397, 12)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + symbol = pyxb.binding.content.ElementUse(trafficSign._UseForTag(pyxb.namespace.ExpandedName(None, 'centerPoint')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 398, 12)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + st_2._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +trafficSign._Automaton = _BuildAutomaton_21() + + + + +ramp._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'orientation'), pyxb.binding.datatypes.float, scope=ramp, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 405, 12))) + +ramp._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'centerPoint'), point, scope=ramp, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 406, 12))) + +def _BuildAutomaton_22 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_22 + del _BuildAutomaton_22 + import pyxb.utils.fac as fac + + counters = set() + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(ramp._UseForTag(pyxb.namespace.ExpandedName(None, 'orientation')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 405, 12)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + symbol = pyxb.binding.content.ElementUse(ramp._UseForTag(pyxb.namespace.ExpandedName(None, 'centerPoint')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 406, 12)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + st_1._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +ramp._Automaton = _BuildAutomaton_22() + + + + +intersection._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'composition'), laneletRefList, scope=intersection, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 414, 12))) + +intersection._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'priority'), CTD_ANON_4, scope=intersection, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 415, 12))) + +def _BuildAutomaton_23 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_23 + del _BuildAutomaton_23 import pyxb.utils.fac as fac counters = set() states = [] final_update = None - symbol = pyxb.binding.content.ElementUse(intersection._UseForTag(pyxb.namespace.ExpandedName(None, 'composition')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 333, 12)) + symbol = pyxb.binding.content.ElementUse(intersection._UseForTag(pyxb.namespace.ExpandedName(None, 'composition')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 414, 12)) st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) states.append(st_0) final_update = set() - symbol = pyxb.binding.content.ElementUse(intersection._UseForTag(pyxb.namespace.ExpandedName(None, 'priority')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 334, 12)) + symbol = pyxb.binding.content.ElementUse(intersection._UseForTag(pyxb.namespace.ExpandedName(None, 'priority')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 415, 12)) st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) states.append(st_1) transitions = [] @@ -2241,55 +2662,73 @@ def _BuildAutomaton_19 (): ])) st_1._set_transitionSet(transitions) return fac.Automaton(states, counters, False, containing_state=None) -intersection._Automaton = _BuildAutomaton_19() +intersection._Automaton = _BuildAutomaton_23() -CommonRoad._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'obstacle'), obstacle, scope=CommonRoad, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 346, 12))) +CommonRoad._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'obstacle'), obstacle, scope=CommonRoad, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 427, 12))) -CommonRoad._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'lanelet'), lanelet, scope=CommonRoad, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 348, 12))) +CommonRoad._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'lanelet'), lanelet, scope=CommonRoad, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 429, 12))) -CommonRoad._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'egoVehicle'), egoVehicle, scope=CommonRoad, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 350, 12))) +CommonRoad._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'egoVehicle'), egoVehicle, scope=CommonRoad, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 431, 12))) -CommonRoad._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'parkingLot'), parkingLot, scope=CommonRoad, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 352, 12))) +CommonRoad._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'parkingLot'), parkingLot, scope=CommonRoad, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 433, 12))) -CommonRoad._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'trafficSign'), trafficSign, scope=CommonRoad, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 354, 12))) +CommonRoad._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'trafficSign'), trafficSign, scope=CommonRoad, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 435, 12))) -CommonRoad._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'intersection'), intersection, scope=CommonRoad, location=pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 356, 12))) +CommonRoad._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'ramp'), ramp, scope=CommonRoad, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 437, 12))) -def _BuildAutomaton_20 (): +CommonRoad._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'intersection'), intersection, scope=CommonRoad, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 439, 12))) + +CommonRoad._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'islandJunction'), trafficIslandJunction, scope=CommonRoad, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 441, 12))) + +CommonRoad._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'roadMarking'), roadMarking, scope=CommonRoad, location=pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 443, 12))) + +def _BuildAutomaton_24 (): # Remove this helper function from the namespace after it is invoked - global _BuildAutomaton_20 - del _BuildAutomaton_20 + global _BuildAutomaton_24 + del _BuildAutomaton_24 import pyxb.utils.fac as fac counters = set() states = [] final_update = set() - symbol = pyxb.binding.content.ElementUse(CommonRoad._UseForTag(pyxb.namespace.ExpandedName(None, 'obstacle')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 346, 12)) + symbol = pyxb.binding.content.ElementUse(CommonRoad._UseForTag(pyxb.namespace.ExpandedName(None, 'obstacle')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 427, 12)) st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) states.append(st_0) final_update = set() - symbol = pyxb.binding.content.ElementUse(CommonRoad._UseForTag(pyxb.namespace.ExpandedName(None, 'lanelet')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 348, 12)) + symbol = pyxb.binding.content.ElementUse(CommonRoad._UseForTag(pyxb.namespace.ExpandedName(None, 'lanelet')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 429, 12)) st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) states.append(st_1) final_update = set() - symbol = pyxb.binding.content.ElementUse(CommonRoad._UseForTag(pyxb.namespace.ExpandedName(None, 'egoVehicle')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 350, 12)) + symbol = pyxb.binding.content.ElementUse(CommonRoad._UseForTag(pyxb.namespace.ExpandedName(None, 'egoVehicle')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 431, 12)) st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) states.append(st_2) final_update = set() - symbol = pyxb.binding.content.ElementUse(CommonRoad._UseForTag(pyxb.namespace.ExpandedName(None, 'parkingLot')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 352, 12)) + symbol = pyxb.binding.content.ElementUse(CommonRoad._UseForTag(pyxb.namespace.ExpandedName(None, 'parkingLot')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 433, 12)) st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) states.append(st_3) final_update = set() - symbol = pyxb.binding.content.ElementUse(CommonRoad._UseForTag(pyxb.namespace.ExpandedName(None, 'trafficSign')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 354, 12)) + symbol = pyxb.binding.content.ElementUse(CommonRoad._UseForTag(pyxb.namespace.ExpandedName(None, 'trafficSign')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 435, 12)) st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) states.append(st_4) final_update = set() - symbol = pyxb.binding.content.ElementUse(CommonRoad._UseForTag(pyxb.namespace.ExpandedName(None, 'intersection')), pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 356, 12)) + symbol = pyxb.binding.content.ElementUse(CommonRoad._UseForTag(pyxb.namespace.ExpandedName(None, 'ramp')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 437, 12)) st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) states.append(st_5) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CommonRoad._UseForTag(pyxb.namespace.ExpandedName(None, 'intersection')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 439, 12)) + st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_6) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CommonRoad._UseForTag(pyxb.namespace.ExpandedName(None, 'islandJunction')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 441, 12)) + st_7 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_7) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CommonRoad._UseForTag(pyxb.namespace.ExpandedName(None, 'roadMarking')), pyxb.utils.utility.Location('/home/mykyta/drive_sim_road_generation/commonroad/schema-extended.xsd', 443, 12)) + st_8 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_8) transitions = [] transitions.append(fac.Transition(st_0, [ ])) @@ -2303,6 +2742,12 @@ def _BuildAutomaton_20 (): ])) transitions.append(fac.Transition(st_5, [ ])) + transitions.append(fac.Transition(st_6, [ + ])) + transitions.append(fac.Transition(st_7, [ + ])) + transitions.append(fac.Transition(st_8, [ + ])) st_0._set_transitionSet(transitions) transitions = [] transitions.append(fac.Transition(st_0, [ @@ -2317,6 +2762,12 @@ def _BuildAutomaton_20 (): ])) transitions.append(fac.Transition(st_5, [ ])) + transitions.append(fac.Transition(st_6, [ + ])) + transitions.append(fac.Transition(st_7, [ + ])) + transitions.append(fac.Transition(st_8, [ + ])) st_1._set_transitionSet(transitions) transitions = [] transitions.append(fac.Transition(st_0, [ @@ -2331,6 +2782,12 @@ def _BuildAutomaton_20 (): ])) transitions.append(fac.Transition(st_5, [ ])) + transitions.append(fac.Transition(st_6, [ + ])) + transitions.append(fac.Transition(st_7, [ + ])) + transitions.append(fac.Transition(st_8, [ + ])) st_2._set_transitionSet(transitions) transitions = [] transitions.append(fac.Transition(st_0, [ @@ -2345,6 +2802,12 @@ def _BuildAutomaton_20 (): ])) transitions.append(fac.Transition(st_5, [ ])) + transitions.append(fac.Transition(st_6, [ + ])) + transitions.append(fac.Transition(st_7, [ + ])) + transitions.append(fac.Transition(st_8, [ + ])) st_3._set_transitionSet(transitions) transitions = [] transitions.append(fac.Transition(st_0, [ @@ -2359,6 +2822,12 @@ def _BuildAutomaton_20 (): ])) transitions.append(fac.Transition(st_5, [ ])) + transitions.append(fac.Transition(st_6, [ + ])) + transitions.append(fac.Transition(st_7, [ + ])) + transitions.append(fac.Transition(st_8, [ + ])) st_4._set_transitionSet(transitions) transitions = [] transitions.append(fac.Transition(st_0, [ @@ -2373,7 +2842,73 @@ def _BuildAutomaton_20 (): ])) transitions.append(fac.Transition(st_5, [ ])) + transitions.append(fac.Transition(st_6, [ + ])) + transitions.append(fac.Transition(st_7, [ + ])) + transitions.append(fac.Transition(st_8, [ + ])) st_5._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_0, [ + ])) + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + transitions.append(fac.Transition(st_3, [ + ])) + transitions.append(fac.Transition(st_4, [ + ])) + transitions.append(fac.Transition(st_5, [ + ])) + transitions.append(fac.Transition(st_6, [ + ])) + transitions.append(fac.Transition(st_7, [ + ])) + transitions.append(fac.Transition(st_8, [ + ])) + st_6._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_0, [ + ])) + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + transitions.append(fac.Transition(st_3, [ + ])) + transitions.append(fac.Transition(st_4, [ + ])) + transitions.append(fac.Transition(st_5, [ + ])) + transitions.append(fac.Transition(st_6, [ + ])) + transitions.append(fac.Transition(st_7, [ + ])) + transitions.append(fac.Transition(st_8, [ + ])) + st_7._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_0, [ + ])) + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + transitions.append(fac.Transition(st_3, [ + ])) + transitions.append(fac.Transition(st_4, [ + ])) + transitions.append(fac.Transition(st_5, [ + ])) + transitions.append(fac.Transition(st_6, [ + ])) + transitions.append(fac.Transition(st_7, [ + ])) + transitions.append(fac.Transition(st_8, [ + ])) + st_8._set_transitionSet(transitions) return fac.Automaton(states, counters, False, containing_state=None) -CommonRoad._Automaton = _BuildAutomaton_20() +CommonRoad._Automaton = _BuildAutomaton_24() diff --git a/commonroad/schema_backup.py b/commonroad/schema_backup.py new file mode 100755 index 0000000..be59a85 --- /dev/null +++ b/commonroad/schema_backup.py @@ -0,0 +1,2927 @@ +# ./commonroad/schema.py +# -*- coding: utf-8 -*- +# PyXB bindings for NM:e92452c8d3e28a9e27abfc9994d2007779e7f4c9 +# Generated 2017-04-26 14:38:36.537036 by PyXB version 1.2.5 using Python 3.5.2.final.0 +# Namespace AbsentNamespace0 + +from __future__ import unicode_literals +import pyxb +import pyxb.binding +import pyxb.binding.saxer +import io +import pyxb.utils.utility +import pyxb.utils.domutils +import sys +import pyxb.utils.six as _six + +# Unique identifier for bindings created at the same time +_GenerationUID = pyxb.utils.utility.UniqueIdentifier('urn:uuid:445dad52-2a7d-11e7-bed2-6d781d4ce578') + +# Version of PyXB used to generate the bindings +_PyXBVersion = '1.2.5' +# Generated bindings are not compatible across PyXB versions +if pyxb.__version__ != _PyXBVersion: + raise pyxb.PyXBVersionError(_PyXBVersion) + +# A holder for module-level binding classes so we can access them from +# inside class definitions where property names may conflict. +_module_typeBindings = pyxb.utils.utility.Object() + +# Import bindings for namespaces imported into schema +import pyxb.binding.datatypes + +# NOTE: All namespace declarations are reserved within the binding +Namespace = pyxb.namespace.CreateAbsentNamespace() +Namespace.configureCategories(['typeBinding', 'elementBinding']) + + +def CreateFromDocument(xml_text, default_namespace=None, location_base=None): + """Parse the given XML and use the document element to create a + Python instance. + + @param xml_text An XML document. This should be data (Python 2 + str or Python 3 bytes), or a text (Python 2 unicode or Python 3 + str) in the L{pyxb._InputEncoding} encoding. + + @keyword default_namespace The L{pyxb.Namespace} instance to use as the + default namespace where there is no default namespace in scope. + If unspecified or C{None}, the namespace of the module containing + this function will be used. + + @keyword location_base: An object to be recorded as the base of all + L{pyxb.utils.utility.Location} instances associated with events and + objects handled by the parser. You might pass the URI from which + the document was obtained. + """ + + if pyxb.XMLStyle_saxer != pyxb._XMLStyle: + dom = pyxb.utils.domutils.StringToDOM(xml_text) + return CreateFromDOM(dom.documentElement, default_namespace=default_namespace) + if default_namespace is None: + default_namespace = Namespace.fallbackNamespace() + saxer = pyxb.binding.saxer.make_parser(fallback_namespace=default_namespace, location_base=location_base) + handler = saxer.getContentHandler() + xmld = xml_text + if isinstance(xmld, _six.text_type): + xmld = xmld.encode(pyxb._InputEncoding) + saxer.parse(io.BytesIO(xmld)) + instance = handler.rootObject() + return instance + + +def CreateFromDOM(node, default_namespace=None): + """Create a Python instance from the given DOM node. + The node tag must correspond to an element declaration in this module. + + @deprecated: Forcing use of DOM interface is unnecessary; use L{CreateFromDocument}.""" + if default_namespace is None: + default_namespace = Namespace.fallbackNamespace() + return pyxb.binding.basis.element.AnyCreateFromDOM(node, default_namespace) + + +# Atomic simple type: distance +class distance(pyxb.binding.datatypes.float): + """An atomic simple type.""" + + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'distance') + _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 4, 4) + _Documentation = None + + +distance._CF_minExclusive = pyxb.binding.facets.CF_minExclusive(value=pyxb.binding.datatypes._fp(0.0), + value_datatype=pyxb.binding.datatypes.float) +distance._InitializeFacetMap(distance._CF_minExclusive) +Namespace.addCategoryObject('typeBinding', 'distance', distance) +_module_typeBindings.distance = distance + + +# Atomic simple type: obstacleRole +class obstacleRole(pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin): + """An atomic simple type.""" + + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'obstacleRole') + _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 153, 4) + _Documentation = None + + +obstacleRole._CF_enumeration = pyxb.binding.facets.CF_enumeration(enum_prefix=None, value_datatype=obstacleRole) +obstacleRole.static = obstacleRole._CF_enumeration.addEnumeration(unicode_value='static', tag='static') +obstacleRole.dynamic = obstacleRole._CF_enumeration.addEnumeration(unicode_value='dynamic', tag='dynamic') +obstacleRole._InitializeFacetMap(obstacleRole._CF_enumeration) +Namespace.addCategoryObject('typeBinding', 'obstacleRole', obstacleRole) +_module_typeBindings.obstacleRole = obstacleRole + + +# Atomic simple type: obstacleType +class obstacleType(pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin): + """An atomic simple type.""" + + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'obstacleType') + _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 160, 4) + _Documentation = None + + +obstacleType._CF_enumeration = pyxb.binding.facets.CF_enumeration(enum_prefix=None, value_datatype=obstacleType) +obstacleType.unknown = obstacleType._CF_enumeration.addEnumeration(unicode_value='unknown', tag='unknown') +obstacleType.parkedVehicle = obstacleType._CF_enumeration.addEnumeration(unicode_value='parkedVehicle', + tag='parkedVehicle') +obstacleType.constructionZone = obstacleType._CF_enumeration.addEnumeration(unicode_value='constructionZone', + tag='constructionZone') +obstacleType.roadBoundary = obstacleType._CF_enumeration.addEnumeration(unicode_value='roadBoundary', + tag='roadBoundary') +obstacleType.car = obstacleType._CF_enumeration.addEnumeration(unicode_value='car', tag='car') +obstacleType.truck = obstacleType._CF_enumeration.addEnumeration(unicode_value='truck', tag='truck') +obstacleType.bus = obstacleType._CF_enumeration.addEnumeration(unicode_value='bus', tag='bus') +obstacleType.bicycle = obstacleType._CF_enumeration.addEnumeration(unicode_value='bicycle', tag='bicycle') +obstacleType.pedestrian = obstacleType._CF_enumeration.addEnumeration(unicode_value='pedestrian', tag='pedestrian') +obstacleType.priorityVehicle = obstacleType._CF_enumeration.addEnumeration(unicode_value='priorityVehicle', + tag='priorityVehicle') +obstacleType.blockedArea = obstacleType._CF_enumeration.addEnumeration(unicode_value='blockedArea', tag='blockedArea') +obstacleType._InitializeFacetMap(obstacleType._CF_enumeration) +Namespace.addCategoryObject('typeBinding', 'obstacleType', obstacleType) +_module_typeBindings.obstacleType = obstacleType + + +# Atomic simple type: lineMarking +class lineMarking(pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin): + """An atomic simple type.""" + + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'lineMarking') + _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 206, 4) + _Documentation = None + + +lineMarking._CF_enumeration = pyxb.binding.facets.CF_enumeration(enum_prefix=None, value_datatype=lineMarking) +lineMarking.dashed = lineMarking._CF_enumeration.addEnumeration(unicode_value='dashed', tag='dashed') +lineMarking.solid = lineMarking._CF_enumeration.addEnumeration(unicode_value='solid', tag='solid') +lineMarking._InitializeFacetMap(lineMarking._CF_enumeration) +Namespace.addCategoryObject('typeBinding', 'lineMarking', lineMarking) +_module_typeBindings.lineMarking = lineMarking + + +# Atomic simple type: drivingDir +class drivingDir(pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin): + """An atomic simple type.""" + + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'drivingDir') + _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 234, 4) + _Documentation = None + + +drivingDir._CF_enumeration = pyxb.binding.facets.CF_enumeration(enum_prefix=None, value_datatype=drivingDir) +drivingDir.same = drivingDir._CF_enumeration.addEnumeration(unicode_value='same', tag='same') +drivingDir.opposite = drivingDir._CF_enumeration.addEnumeration(unicode_value='opposite', tag='opposite') +drivingDir._InitializeFacetMap(drivingDir._CF_enumeration) +Namespace.addCategoryObject('typeBinding', 'drivingDir', drivingDir) +_module_typeBindings.drivingDir = drivingDir + + +# Atomic simple type: laneletType +class laneletType(pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin): + """An atomic simple type.""" + + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'laneletType') + _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 247, 4) + _Documentation = None + + +laneletType._CF_enumeration = pyxb.binding.facets.CF_enumeration(enum_prefix=None, value_datatype=laneletType) +laneletType.road = laneletType._CF_enumeration.addEnumeration(unicode_value='road', tag='road') +laneletType.sidewalk = laneletType._CF_enumeration.addEnumeration(unicode_value='sidewalk', tag='sidewalk') +laneletType.zebraCrossing = laneletType._CF_enumeration.addEnumeration(unicode_value='zebraCrossing', + tag='zebraCrossing') +laneletType._InitializeFacetMap(laneletType._CF_enumeration) +Namespace.addCategoryObject('typeBinding', 'laneletType', laneletType) +_module_typeBindings.laneletType = laneletType + + +# Atomic simple type: [anonymous] +class STD_ANON(pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin): + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 304, 16) + _Documentation = None + + +STD_ANON._CF_enumeration = pyxb.binding.facets.CF_enumeration(enum_prefix=None, value_datatype=STD_ANON) +STD_ANON.stvo_306 = STD_ANON._CF_enumeration.addEnumeration(unicode_value='stvo-306', tag='stvo_306') +STD_ANON.stvo_205 = STD_ANON._CF_enumeration.addEnumeration(unicode_value='stvo-205', tag='stvo_205') +STD_ANON.stvo_206 = STD_ANON._CF_enumeration.addEnumeration(unicode_value='stvo-206', tag='stvo_206') +STD_ANON.stvo_208 = STD_ANON._CF_enumeration.addEnumeration(unicode_value='stvo-208', tag='stvo_208') +STD_ANON.stvo_276 = STD_ANON._CF_enumeration.addEnumeration(unicode_value='stvo-276', tag='stvo_276') +STD_ANON.stvo_280 = STD_ANON._CF_enumeration.addEnumeration(unicode_value='stvo-280', tag='stvo_280') +STD_ANON.stvo_274_1 = STD_ANON._CF_enumeration.addEnumeration(unicode_value='stvo-274.1', tag='stvo_274_1') +STD_ANON.stvo_274_2 = STD_ANON._CF_enumeration.addEnumeration(unicode_value='stvo-274.2', tag='stvo_274_2') +STD_ANON.stvo_350_10 = STD_ANON._CF_enumeration.addEnumeration(unicode_value='stvo-350-10', tag='stvo_350_10') +STD_ANON.stvo_209_10 = STD_ANON._CF_enumeration.addEnumeration(unicode_value='stvo-209-10', tag='stvo_209_10') +STD_ANON.stvo_209_20 = STD_ANON._CF_enumeration.addEnumeration(unicode_value='stvo-209-20', tag='stvo_209_20') +STD_ANON.stvo_625_10 = STD_ANON._CF_enumeration.addEnumeration(unicode_value='stvo-625-10', tag='stvo_625_10') +STD_ANON.stvo_625_11 = STD_ANON._CF_enumeration.addEnumeration(unicode_value='stvo-625-11', tag='stvo_625_11') +STD_ANON.stvo_625_20 = STD_ANON._CF_enumeration.addEnumeration(unicode_value='stvo-625-20', tag='stvo_625_20') +STD_ANON.stvo_625_21 = STD_ANON._CF_enumeration.addEnumeration(unicode_value='stvo-625-21', tag='stvo_625_21') +STD_ANON._InitializeFacetMap(STD_ANON._CF_enumeration) +_module_typeBindings.STD_ANON = STD_ANON + + +# Atomic simple type: [anonymous] +class STD_ANON_(pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin): + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 360, 12) + _Documentation = None + + +STD_ANON_._CF_enumeration = pyxb.binding.facets.CF_enumeration(enum_prefix=None, value_datatype=STD_ANON_) +STD_ANON_.n1_0 = STD_ANON_._CF_enumeration.addEnumeration(unicode_value='1.0', tag='n1_0') +STD_ANON_._InitializeFacetMap(STD_ANON_._CF_enumeration) +_module_typeBindings.STD_ANON_ = STD_ANON_ + + +# Complex type floatInterval with content type ELEMENT_ONLY +class floatInterval(pyxb.binding.basis.complexTypeDefinition): + """Complex type floatInterval with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'floatInterval') + _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 19, 4) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element exact uses Python identifier exact + __exact = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'exact'), 'exact', + '__AbsentNamespace0_floatInterval_exact', False, + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 21, + 12), ) + + exact = property(__exact.value, __exact.set, None, None) + + # Element intervalStart uses Python identifier intervalStart + __intervalStart = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'intervalStart'), + 'intervalStart', + '__AbsentNamespace0_floatInterval_intervalStart', False, + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', + 23, 16), ) + + intervalStart = property(__intervalStart.value, __intervalStart.set, None, None) + + # Element intervalEnd uses Python identifier intervalEnd + __intervalEnd = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'intervalEnd'), + 'intervalEnd', + '__AbsentNamespace0_floatInterval_intervalEnd', False, + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', + 24, 16), ) + + intervalEnd = property(__intervalEnd.value, __intervalEnd.set, None, None) + + _ElementMap.update({ + __exact.name(): __exact, + __intervalStart.name(): __intervalStart, + __intervalEnd.name(): __intervalEnd + }) + _AttributeMap.update({ + + }) + + +_module_typeBindings.floatInterval = floatInterval +Namespace.addCategoryObject('typeBinding', 'floatInterval', floatInterval) + + +# Complex type point with content type ELEMENT_ONLY +class point(pyxb.binding.basis.complexTypeDefinition): + """Complex type point with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'point') + _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 36, 4) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element x uses Python identifier x + __x = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'x'), 'x', + '__AbsentNamespace0_point_x', False, pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 38, 12), ) + + x = property(__x.value, __x.set, None, None) + + # Element y uses Python identifier y + __y = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'y'), 'y', + '__AbsentNamespace0_point_y', False, pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 39, 12), ) + + y = property(__y.value, __y.set, None, None) + + _ElementMap.update({ + __x.name(): __x, + __y.name(): __y + }) + _AttributeMap.update({ + + }) + + +_module_typeBindings.point = point +Namespace.addCategoryObject('typeBinding', 'point', point) + + +# Complex type rectangle with content type ELEMENT_ONLY +class rectangle(pyxb.binding.basis.complexTypeDefinition): + """Complex type rectangle with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'rectangle') + _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 55, 4) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element length uses Python identifier length + __length = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'length'), 'length', + '__AbsentNamespace0_rectangle_length', False, + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 57, + 12), ) + + length = property(__length.value, __length.set, None, None) + + # Element width uses Python identifier width + __width = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'width'), 'width', + '__AbsentNamespace0_rectangle_width', False, + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 58, + 12), ) + + width = property(__width.value, __width.set, None, None) + + # Element orientation uses Python identifier orientation + __orientation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'orientation'), + 'orientation', '__AbsentNamespace0_rectangle_orientation', + False, pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 59, 12), ) + + orientation = property(__orientation.value, __orientation.set, None, None) + + # Element centerPoint uses Python identifier centerPoint + __centerPoint = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'centerPoint'), + 'centerPoint', '__AbsentNamespace0_rectangle_centerPoint', + False, pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 60, 12), ) + + centerPoint = property(__centerPoint.value, __centerPoint.set, None, None) + + _ElementMap.update({ + __length.name(): __length, + __width.name(): __width, + __orientation.name(): __orientation, + __centerPoint.name(): __centerPoint + }) + _AttributeMap.update({ + + }) + + +_module_typeBindings.rectangle = rectangle +Namespace.addCategoryObject('typeBinding', 'rectangle', rectangle) + + +# Complex type circle with content type ELEMENT_ONLY +class circle(pyxb.binding.basis.complexTypeDefinition): + """Complex type circle with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'circle') + _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 74, 4) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element radius uses Python identifier radius + __radius = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'radius'), 'radius', + '__AbsentNamespace0_circle_radius', False, + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 76, + 12), ) + + radius = property(__radius.value, __radius.set, None, None) + + # Element centerPoint uses Python identifier centerPoint + __centerPoint = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'centerPoint'), + 'centerPoint', '__AbsentNamespace0_circle_centerPoint', + False, pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 77, 12), ) + + centerPoint = property(__centerPoint.value, __centerPoint.set, None, None) + + _ElementMap.update({ + __radius.name(): __radius, + __centerPoint.name(): __centerPoint + }) + _AttributeMap.update({ + + }) + + +_module_typeBindings.circle = circle +Namespace.addCategoryObject('typeBinding', 'circle', circle) + + +# Complex type polygon with content type ELEMENT_ONLY +class polygon(pyxb.binding.basis.complexTypeDefinition): + """Complex type polygon with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'polygon') + _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 99, 4) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element point uses Python identifier point + __point = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'point'), 'point', + '__AbsentNamespace0_polygon_point', True, + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 101, + 12), ) + + point = property(__point.value, __point.set, None, None) + + _ElementMap.update({ + __point.name(): __point + }) + _AttributeMap.update({ + + }) + + +_module_typeBindings.polygon = polygon +Namespace.addCategoryObject('typeBinding', 'polygon', polygon) + + +# Complex type shape with content type ELEMENT_ONLY +class shape(pyxb.binding.basis.complexTypeDefinition): + """Complex type shape with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'shape') + _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 117, 4) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element rectangle uses Python identifier rectangle + __rectangle = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'rectangle'), 'rectangle', + '__AbsentNamespace0_shape_rectangle', True, + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', + 119, 12), ) + + rectangle = property(__rectangle.value, __rectangle.set, None, None) + + # Element circle uses Python identifier circle + __circle = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'circle'), 'circle', + '__AbsentNamespace0_shape_circle', True, + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', + 120, 12), ) + + circle = property(__circle.value, __circle.set, None, None) + + # Element polygon uses Python identifier polygon + __polygon = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'polygon'), 'polygon', + '__AbsentNamespace0_shape_polygon', True, + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', + 121, 12), ) + + polygon = property(__polygon.value, __polygon.set, None, None) + + _ElementMap.update({ + __rectangle.name(): __rectangle, + __circle.name(): __circle, + __polygon.name(): __polygon + }) + _AttributeMap.update({ + + }) + + +_module_typeBindings.shape = shape +Namespace.addCategoryObject('typeBinding', 'shape', shape) + + +# Complex type occupancy with content type ELEMENT_ONLY +class occupancy(pyxb.binding.basis.complexTypeDefinition): + """Complex type occupancy with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'occupancy') + _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 125, 4) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element shape uses Python identifier shape + __shape = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'shape'), 'shape', + '__AbsentNamespace0_occupancy_shape', False, + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 127, + 12), ) + + shape = property(__shape.value, __shape.set, None, None) + + # Element time uses Python identifier time + __time = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'time'), 'time', + '__AbsentNamespace0_occupancy_time', False, + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 128, + 12), ) + + time = property(__time.value, __time.set, None, None) + + _ElementMap.update({ + __shape.name(): __shape, + __time.name(): __time + }) + _AttributeMap.update({ + + }) + + +_module_typeBindings.occupancy = occupancy +Namespace.addCategoryObject('typeBinding', 'occupancy', occupancy) + + +# Complex type state with content type ELEMENT_ONLY +class state(pyxb.binding.basis.complexTypeDefinition): + """Complex type state with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'state') + _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 132, 4) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element position uses Python identifier position + __position = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'position'), 'position', + '__AbsentNamespace0_state_position', False, + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', + 134, 12), ) + + position = property(__position.value, __position.set, None, None) + + # Element orientation uses Python identifier orientation + __orientation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'orientation'), + 'orientation', '__AbsentNamespace0_state_orientation', + False, pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 146, 12), ) + + orientation = property(__orientation.value, __orientation.set, None, None) + + # Element time uses Python identifier time + __time = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'time'), 'time', + '__AbsentNamespace0_state_time', False, + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 147, + 12), ) + + time = property(__time.value, __time.set, None, None) + + # Element velocity uses Python identifier velocity + __velocity = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'velocity'), 'velocity', + '__AbsentNamespace0_state_velocity', False, + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', + 148, 12), ) + + velocity = property(__velocity.value, __velocity.set, None, None) + + # Element acceleration uses Python identifier acceleration + __acceleration = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'acceleration'), + 'acceleration', '__AbsentNamespace0_state_acceleration', + False, pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 149, 12), ) + + acceleration = property(__acceleration.value, __acceleration.set, None, None) + + _ElementMap.update({ + __position.name(): __position, + __orientation.name(): __orientation, + __time.name(): __time, + __velocity.name(): __velocity, + __acceleration.name(): __acceleration + }) + _AttributeMap.update({ + + }) + + +_module_typeBindings.state = state +Namespace.addCategoryObject('typeBinding', 'state', state) + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON(pyxb.binding.basis.complexTypeDefinition): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 135, 16) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element point uses Python identifier point + __point = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'point'), 'point', + '__AbsentNamespace0_CTD_ANON_point', False, + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 137, + 24), ) + + point = property(__point.value, __point.set, None, None) + + # Element rectangle uses Python identifier rectangle + __rectangle = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'rectangle'), 'rectangle', + '__AbsentNamespace0_CTD_ANON_rectangle', True, + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', + 139, 28), ) + + rectangle = property(__rectangle.value, __rectangle.set, None, None) + + # Element circle uses Python identifier circle + __circle = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'circle'), 'circle', + '__AbsentNamespace0_CTD_ANON_circle', True, + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', + 140, 28), ) + + circle = property(__circle.value, __circle.set, None, None) + + # Element polygon uses Python identifier polygon + __polygon = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'polygon'), 'polygon', + '__AbsentNamespace0_CTD_ANON_polygon', True, + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', + 141, 28), ) + + polygon = property(__polygon.value, __polygon.set, None, None) + + _ElementMap.update({ + __point.name(): __point, + __rectangle.name(): __rectangle, + __circle.name(): __circle, + __polygon.name(): __polygon + }) + _AttributeMap.update({ + + }) + + +_module_typeBindings.CTD_ANON = CTD_ANON + + +# Complex type obstacle with content type ELEMENT_ONLY +class obstacle(pyxb.binding.basis.complexTypeDefinition): + """Complex type obstacle with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'obstacle') + _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 179, 4) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element role uses Python identifier role + __role = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'role'), 'role', + '__AbsentNamespace0_obstacle_role', False, + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 181, + 12), ) + + role = property(__role.value, __role.set, None, None) + + # Element type uses Python identifier type + __type = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'type'), 'type', + '__AbsentNamespace0_obstacle_type', False, + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 182, + 12), ) + + type = property(__type.value, __type.set, None, None) + + # Element shape uses Python identifier shape + __shape = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'shape'), 'shape', + '__AbsentNamespace0_obstacle_shape', False, + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 183, + 12), ) + + shape = property(__shape.value, __shape.set, None, None) + + # Element trajectory uses Python identifier trajectory + __trajectory = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'trajectory'), + 'trajectory', '__AbsentNamespace0_obstacle_trajectory', + False, pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 185, 16), ) + + trajectory = property(__trajectory.value, __trajectory.set, None, None) + + # Element occupancySet uses Python identifier occupancySet + __occupancySet = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'occupancySet'), + 'occupancySet', '__AbsentNamespace0_obstacle_occupancySet', + False, pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 193, 16), ) + + occupancySet = property(__occupancySet.value, __occupancySet.set, None, None) + + # Attribute id uses Python identifier id + __id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'id'), 'id', + '__AbsentNamespace0_obstacle_id', pyxb.binding.datatypes.integer, + required=True) + __id._DeclarationLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', + 203, 8) + __id._UseLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 203, 8) + + id = property(__id.value, __id.set, None, None) + + _ElementMap.update({ + __role.name(): __role, + __type.name(): __type, + __shape.name(): __shape, + __trajectory.name(): __trajectory, + __occupancySet.name(): __occupancySet + }) + _AttributeMap.update({ + __id.name(): __id + }) + + +_module_typeBindings.obstacle = obstacle +Namespace.addCategoryObject('typeBinding', 'obstacle', obstacle) + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_(pyxb.binding.basis.complexTypeDefinition): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 186, 20) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element state uses Python identifier state + __state = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'state'), 'state', + '__AbsentNamespace0_CTD_ANON__state', True, + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 188, + 28), ) + + state = property(__state.value, __state.set, None, None) + + _ElementMap.update({ + __state.name(): __state + }) + _AttributeMap.update({ + + }) + + +_module_typeBindings.CTD_ANON_ = CTD_ANON_ + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_2(pyxb.binding.basis.complexTypeDefinition): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 194, 20) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element occupancy uses Python identifier occupancy + __occupancy = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'occupancy'), 'occupancy', + '__AbsentNamespace0_CTD_ANON_2_occupancy', True, + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', + 196, 28), ) + + occupancy = property(__occupancy.value, __occupancy.set, None, None) + + _ElementMap.update({ + __occupancy.name(): __occupancy + }) + _AttributeMap.update({ + + }) + + +_module_typeBindings.CTD_ANON_2 = CTD_ANON_2 + + +# Complex type boundary with content type ELEMENT_ONLY +class boundary(pyxb.binding.basis.complexTypeDefinition): + """Complex type boundary with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'boundary') + _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 213, 4) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element point uses Python identifier point + __point = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'point'), 'point', + '__AbsentNamespace0_boundary_point', True, + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 215, + 12), ) + + point = property(__point.value, __point.set, None, None) + + # Element lineMarking uses Python identifier lineMarking + __lineMarking = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'lineMarking'), + 'lineMarking', '__AbsentNamespace0_boundary_lineMarking', + False, pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 217, 12), ) + + lineMarking = property(__lineMarking.value, __lineMarking.set, None, None) + + _ElementMap.update({ + __point.name(): __point, + __lineMarking.name(): __lineMarking + }) + _AttributeMap.update({ + + }) + + +_module_typeBindings.boundary = boundary +Namespace.addCategoryObject('typeBinding', 'boundary', boundary) + + +# Complex type laneletRef with content type EMPTY +class laneletRef(pyxb.binding.basis.complexTypeDefinition): + """Complex type laneletRef with content type EMPTY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'laneletRef') + _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 222, 4) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Attribute ref uses Python identifier ref + __ref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ref'), 'ref', + '__AbsentNamespace0_laneletRef_ref', pyxb.binding.datatypes.integer, + required=True) + __ref._DeclarationLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', + 223, 8) + __ref._UseLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 223, 8) + + ref = property(__ref.value, __ref.set, None, None) + + _ElementMap.update({ + + }) + _AttributeMap.update({ + __ref.name(): __ref + }) + + +_module_typeBindings.laneletRef = laneletRef +Namespace.addCategoryObject('typeBinding', 'laneletRef', laneletRef) + + +# Complex type laneletRefList with content type ELEMENT_ONLY +class laneletRefList(pyxb.binding.basis.complexTypeDefinition): + """Complex type laneletRefList with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'laneletRefList') + _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 227, 4) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element lanelet uses Python identifier lanelet + __lanelet = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'lanelet'), 'lanelet', + '__AbsentNamespace0_laneletRefList_lanelet', True, + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', + 229, 12), ) + + lanelet = property(__lanelet.value, __lanelet.set, None, None) + + _ElementMap.update({ + __lanelet.name(): __lanelet + }) + _AttributeMap.update({ + + }) + + +_module_typeBindings.laneletRefList = laneletRefList +Namespace.addCategoryObject('typeBinding', 'laneletRefList', laneletRefList) + + +# Complex type lanelet with content type ELEMENT_ONLY +class lanelet(pyxb.binding.basis.complexTypeDefinition): + """Complex type lanelet with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'lanelet') + _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 255, 4) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element type uses Python identifier type + __type = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'type'), 'type', + '__AbsentNamespace0_lanelet_type', False, + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 257, + 12), ) + + type = property(__type.value, __type.set, None, None) + + # Element isStart uses Python identifier isStart + __isStart = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'isStart'), 'isStart', + '__AbsentNamespace0_lanelet_isStart', False, + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', + 258, 12), ) + + isStart = property(__isStart.value, __isStart.set, None, None) + + # Element leftBoundary uses Python identifier leftBoundary + __leftBoundary = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'leftBoundary'), + 'leftBoundary', '__AbsentNamespace0_lanelet_leftBoundary', + False, pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 259, 12), ) + + leftBoundary = property(__leftBoundary.value, __leftBoundary.set, None, None) + + # Element rightBoundary uses Python identifier rightBoundary + __rightBoundary = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'rightBoundary'), + 'rightBoundary', + '__AbsentNamespace0_lanelet_rightBoundary', False, + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', + 260, 12), ) + + rightBoundary = property(__rightBoundary.value, __rightBoundary.set, None, None) + + # Element predecessor uses Python identifier predecessor + __predecessor = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'predecessor'), + 'predecessor', '__AbsentNamespace0_lanelet_predecessor', + False, pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 261, 12), ) + + predecessor = property(__predecessor.value, __predecessor.set, None, None) + + # Element successor uses Python identifier successor + __successor = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'successor'), 'successor', + '__AbsentNamespace0_lanelet_successor', False, + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', + 263, 12), ) + + successor = property(__successor.value, __successor.set, None, None) + + # Element adjacentLeft uses Python identifier adjacentLeft + __adjacentLeft = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'adjacentLeft'), + 'adjacentLeft', '__AbsentNamespace0_lanelet_adjacentLeft', + False, pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 265, 12), ) + + adjacentLeft = property(__adjacentLeft.value, __adjacentLeft.set, None, None) + + # Element adjacentRight uses Python identifier adjacentRight + __adjacentRight = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'adjacentRight'), + 'adjacentRight', + '__AbsentNamespace0_lanelet_adjacentRight', False, + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', + 267, 12), ) + + adjacentRight = property(__adjacentRight.value, __adjacentRight.set, None, None) + + # Element stopLine uses Python identifier stopLine + __stopLine = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'stopLine'), 'stopLine', + '__AbsentNamespace0_lanelet_stopLine', False, + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', + 270, 12), ) + + stopLine = property(__stopLine.value, __stopLine.set, None, None) + + # Attribute id uses Python identifier id + __id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'id'), 'id', + '__AbsentNamespace0_lanelet_id', pyxb.binding.datatypes.integer, + required=True) + __id._DeclarationLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', + 272, 8) + __id._UseLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 272, 8) + + id = property(__id.value, __id.set, None, None) + + _ElementMap.update({ + __type.name(): __type, + __isStart.name(): __isStart, + __leftBoundary.name(): __leftBoundary, + __rightBoundary.name(): __rightBoundary, + __predecessor.name(): __predecessor, + __successor.name(): __successor, + __adjacentLeft.name(): __adjacentLeft, + __adjacentRight.name(): __adjacentRight, + __stopLine.name(): __stopLine + }) + _AttributeMap.update({ + __id.name(): __id + }) + + +_module_typeBindings.lanelet = lanelet +Namespace.addCategoryObject('typeBinding', 'lanelet', lanelet) + + +# Complex type egoVehicle with content type ELEMENT_ONLY +class egoVehicle(pyxb.binding.basis.complexTypeDefinition): + """Complex type egoVehicle with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'egoVehicle') + _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 275, 4) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element type uses Python identifier type + __type = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'type'), 'type', + '__AbsentNamespace0_egoVehicle_type', False, + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 277, + 12), ) + + type = property(__type.value, __type.set, None, None) + + # Element shape uses Python identifier shape + __shape = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'shape'), 'shape', + '__AbsentNamespace0_egoVehicle_shape', False, + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 278, + 12), ) + + shape = property(__shape.value, __shape.set, None, None) + + # Element initialState uses Python identifier initialState + __initialState = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'initialState'), + 'initialState', + '__AbsentNamespace0_egoVehicle_initialState', False, + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', + 279, 12), ) + + initialState = property(__initialState.value, __initialState.set, None, None) + + # Element goalRegion uses Python identifier goalRegion + __goalRegion = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'goalRegion'), + 'goalRegion', '__AbsentNamespace0_egoVehicle_goalRegion', + False, pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 280, 12), ) + + goalRegion = property(__goalRegion.value, __goalRegion.set, None, None) + + # Attribute id uses Python identifier id + __id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'id'), 'id', + '__AbsentNamespace0_egoVehicle_id', pyxb.binding.datatypes.integer, + required=True) + __id._DeclarationLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', + 289, 8) + __id._UseLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 289, 8) + + id = property(__id.value, __id.set, None, None) + + _ElementMap.update({ + __type.name(): __type, + __shape.name(): __shape, + __initialState.name(): __initialState, + __goalRegion.name(): __goalRegion + }) + _AttributeMap.update({ + __id.name(): __id + }) + + +_module_typeBindings.egoVehicle = egoVehicle +Namespace.addCategoryObject('typeBinding', 'egoVehicle', egoVehicle) + + +# Complex type [anonymous] with content type ELEMENT_ONLY +class CTD_ANON_3(pyxb.binding.basis.complexTypeDefinition): + """Complex type [anonymous] with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 281, 16) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element state uses Python identifier state + __state = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'state'), 'state', + '__AbsentNamespace0_CTD_ANON_3_state', True, + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 283, + 24), ) + + state = property(__state.value, __state.set, None, None) + + _ElementMap.update({ + __state.name(): __state + }) + _AttributeMap.update({ + + }) + + +_module_typeBindings.CTD_ANON_3 = CTD_ANON_3 + + +# Complex type parkingLot with content type ELEMENT_ONLY +class parkingLot(pyxb.binding.basis.complexTypeDefinition): + """Complex type parkingLot with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'parkingLot') + _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 293, 4) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element shape uses Python identifier shape + __shape = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'shape'), 'shape', + '__AbsentNamespace0_parkingLot_shape', False, + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 295, + 12), ) + + shape = property(__shape.value, __shape.set, None, None) + + # Attribute id uses Python identifier id + __id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'id'), 'id', + '__AbsentNamespace0_parkingLot_id', pyxb.binding.datatypes.integer, + required=True) + __id._DeclarationLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', + 297, 8) + __id._UseLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 297, 8) + + id = property(__id.value, __id.set, None, None) + + _ElementMap.update({ + __shape.name(): __shape + }) + _AttributeMap.update({ + __id.name(): __id + }) + + +_module_typeBindings.parkingLot = parkingLot +Namespace.addCategoryObject('typeBinding', 'parkingLot', parkingLot) + + +# Complex type trafficSign with content type ELEMENT_ONLY +class trafficSign(pyxb.binding.basis.complexTypeDefinition): + """Complex type trafficSign with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'trafficSign') + _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 301, 4) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element type uses Python identifier type + __type = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'type'), 'type', + '__AbsentNamespace0_trafficSign_type', False, + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 303, + 12), ) + + type = property(__type.value, __type.set, None, None) + + # Element orientation uses Python identifier orientation + __orientation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'orientation'), + 'orientation', '__AbsentNamespace0_trafficSign_orientation', + False, pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 324, 12), ) + + orientation = property(__orientation.value, __orientation.set, None, None) + + # Element centerPoint uses Python identifier centerPoint + __centerPoint = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'centerPoint'), + 'centerPoint', '__AbsentNamespace0_trafficSign_centerPoint', + False, pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 325, 12), ) + + centerPoint = property(__centerPoint.value, __centerPoint.set, None, None) + + # Attribute id uses Python identifier id + __id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'id'), 'id', + '__AbsentNamespace0_trafficSign_id', pyxb.binding.datatypes.integer, + required=True) + __id._DeclarationLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', + 327, 8) + __id._UseLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 327, 8) + + id = property(__id.value, __id.set, None, None) + + _ElementMap.update({ + __type.name(): __type, + __orientation.name(): __orientation, + __centerPoint.name(): __centerPoint + }) + _AttributeMap.update({ + __id.name(): __id + }) + + +_module_typeBindings.trafficSign = trafficSign +Namespace.addCategoryObject('typeBinding', 'trafficSign', trafficSign) + + +# Complex type intersection with content type ELEMENT_ONLY +class intersection(pyxb.binding.basis.complexTypeDefinition): + """Complex type intersection with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'intersection') + _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 331, 4) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element composition uses Python identifier composition + __composition = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'composition'), + 'composition', + '__AbsentNamespace0_intersection_composition', False, + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', + 333, 12), ) + + composition = property(__composition.value, __composition.set, None, None) + + # Element priority uses Python identifier priority + __priority = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'priority'), 'priority', + '__AbsentNamespace0_intersection_priority', True, + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', + 334, 12), ) + + priority = property(__priority.value, __priority.set, None, None) + + # Attribute id uses Python identifier id + __id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'id'), 'id', + '__AbsentNamespace0_intersection_id', pyxb.binding.datatypes.integer, + required=True) + __id._DeclarationLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', + 341, 8) + __id._UseLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 341, 8) + + id = property(__id.value, __id.set, None, None) + + _ElementMap.update({ + __composition.name(): __composition, + __priority.name(): __priority + }) + _AttributeMap.update({ + __id.name(): __id + }) + + +_module_typeBindings.intersection = intersection +Namespace.addCategoryObject('typeBinding', 'intersection', intersection) + + +# Complex type [anonymous] with content type EMPTY +class CTD_ANON_4(pyxb.binding.basis.complexTypeDefinition): + """Complex type [anonymous] with content type EMPTY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY + _Abstract = False + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 335, 16) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Attribute low uses Python identifier low + __low = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'low'), 'low', + '__AbsentNamespace0_CTD_ANON_4_low', pyxb.binding.datatypes.integer, + required=True) + __low._DeclarationLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', + 336, 20) + __low._UseLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 336, 20) + + low = property(__low.value, __low.set, None, None) + + # Attribute high uses Python identifier high + __high = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'high'), 'high', + '__AbsentNamespace0_CTD_ANON_4_high', pyxb.binding.datatypes.integer, + required=True) + __high._DeclarationLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', + 337, 20) + __high._UseLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 337, 20) + + high = property(__high.value, __high.set, None, None) + + _ElementMap.update({ + + }) + _AttributeMap.update({ + __low.name(): __low, + __high.name(): __high + }) + + +_module_typeBindings.CTD_ANON_4 = CTD_ANON_4 + + +# Complex type laneletAdjacentRef with content type EMPTY +class laneletAdjacentRef(pyxb.binding.basis.complexTypeDefinition): + """Complex type laneletAdjacentRef with content type EMPTY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'laneletAdjacentRef') + _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 241, 4) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Attribute ref uses Python identifier ref + __ref = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ref'), 'ref', + '__AbsentNamespace0_laneletAdjacentRef_ref', + pyxb.binding.datatypes.integer, required=True) + __ref._DeclarationLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', + 242, 8) + __ref._UseLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 242, 8) + + ref = property(__ref.value, __ref.set, None, None) + + # Attribute drivingDir uses Python identifier drivingDir + __drivingDir = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'drivingDir'), 'drivingDir', + '__AbsentNamespace0_laneletAdjacentRef_drivingDir', + _module_typeBindings.drivingDir, required=True) + __drivingDir._DeclarationLocation = pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 243, 8) + __drivingDir._UseLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', + 243, 8) + + drivingDir = property(__drivingDir.value, __drivingDir.set, None, None) + + _ElementMap.update({ + + }) + _AttributeMap.update({ + __ref.name(): __ref, + __drivingDir.name(): __drivingDir + }) + + +_module_typeBindings.laneletAdjacentRef = laneletAdjacentRef +Namespace.addCategoryObject('typeBinding', 'laneletAdjacentRef', laneletAdjacentRef) + + +# Complex type CommonRoad with content type ELEMENT_ONLY +class CommonRoad(pyxb.binding.basis.complexTypeDefinition): + """Complex type CommonRoad with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'CommonRoad') + _XSDLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 344, 4) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element obstacle uses Python identifier obstacle + __obstacle = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'obstacle'), 'obstacle', + '__AbsentNamespace0_CommonRoad_obstacle', True, + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', + 346, 12), ) + + obstacle = property(__obstacle.value, __obstacle.set, None, None) + + # Element lanelet uses Python identifier lanelet + __lanelet = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'lanelet'), 'lanelet', + '__AbsentNamespace0_CommonRoad_lanelet', True, + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', + 348, 12), ) + + lanelet = property(__lanelet.value, __lanelet.set, None, None) + + # Element egoVehicle uses Python identifier egoVehicle + __egoVehicle = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'egoVehicle'), + 'egoVehicle', '__AbsentNamespace0_CommonRoad_egoVehicle', + True, pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 350, 12), ) + + egoVehicle = property(__egoVehicle.value, __egoVehicle.set, None, None) + + # Element parkingLot uses Python identifier parkingLot + __parkingLot = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'parkingLot'), + 'parkingLot', '__AbsentNamespace0_CommonRoad_parkingLot', + True, pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 352, 12), ) + + parkingLot = property(__parkingLot.value, __parkingLot.set, None, None) + + # Element trafficSign uses Python identifier trafficSign + __trafficSign = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'trafficSign'), + 'trafficSign', '__AbsentNamespace0_CommonRoad_trafficSign', + True, pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 354, 12), ) + + trafficSign = property(__trafficSign.value, __trafficSign.set, None, None) + + # Element intersection uses Python identifier intersection + __intersection = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'intersection'), + 'intersection', + '__AbsentNamespace0_CommonRoad_intersection', True, + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', + 356, 12), ) + + intersection = property(__intersection.value, __intersection.set, None, None) + + # Attribute commonRoadVersion uses Python identifier commonRoadVersion + __commonRoadVersion = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'commonRoadVersion'), + 'commonRoadVersion', + '__AbsentNamespace0_CommonRoad_commonRoadVersion', + _module_typeBindings.STD_ANON_, required=True) + __commonRoadVersion._DeclarationLocation = pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 359, 8) + __commonRoadVersion._UseLocation = pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 359, 8) + + commonRoadVersion = property(__commonRoadVersion.value, __commonRoadVersion.set, None, None) + + # Attribute benchmarkID uses Python identifier benchmarkID + __benchmarkID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'benchmarkID'), 'benchmarkID', + '__AbsentNamespace0_CommonRoad_benchmarkID', + pyxb.binding.datatypes.string) + __benchmarkID._DeclarationLocation = pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 366, 8) + __benchmarkID._UseLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', + 366, 8) + + benchmarkID = property(__benchmarkID.value, __benchmarkID.set, None, None) + + # Attribute date uses Python identifier date + __date = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'date'), 'date', + '__AbsentNamespace0_CommonRoad_date', pyxb.binding.datatypes.date) + __date._DeclarationLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', + 367, 8) + __date._UseLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 367, 8) + + date = property(__date.value, __date.set, None, None) + + # Attribute timeStepSize uses Python identifier timeStepSize + __timeStepSize = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'timeStepSize'), + 'timeStepSize', '__AbsentNamespace0_CommonRoad_timeStepSize', + pyxb.binding.datatypes.float) + __timeStepSize._DeclarationLocation = pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 368, 8) + __timeStepSize._UseLocation = pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', + 368, 8) + + timeStepSize = property(__timeStepSize.value, __timeStepSize.set, None, None) + + _ElementMap.update({ + __obstacle.name(): __obstacle, + __lanelet.name(): __lanelet, + __egoVehicle.name(): __egoVehicle, + __parkingLot.name(): __parkingLot, + __trafficSign.name(): __trafficSign, + __intersection.name(): __intersection + }) + _AttributeMap.update({ + __commonRoadVersion.name(): __commonRoadVersion, + __benchmarkID.name(): __benchmarkID, + __date.name(): __date, + __timeStepSize.name(): __timeStepSize + }) + + +_module_typeBindings.CommonRoad = CommonRoad +Namespace.addCategoryObject('typeBinding', 'CommonRoad', CommonRoad) + +commonRoad = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'commonRoad'), CommonRoad, + location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 372, 4)) +Namespace.addCategoryObject('elementBinding', commonRoad.name().localName(), commonRoad) + +floatInterval._AddElement( + pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'exact'), pyxb.binding.datatypes.float, + scope=floatInterval, location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 21, 12))) + +floatInterval._AddElement( + pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'intervalStart'), pyxb.binding.datatypes.float, + scope=floatInterval, location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 23, 16))) + +floatInterval._AddElement( + pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'intervalEnd'), pyxb.binding.datatypes.float, + scope=floatInterval, location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 24, 16))) + + +def _BuildAutomaton(): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton + del _BuildAutomaton + import pyxb.utils.fac as fac + + counters = set() + states = [] + final_update = set() + symbol = pyxb.binding.content.ElementUse(floatInterval._UseForTag(pyxb.namespace.ExpandedName(None, 'exact')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 21, 12)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse( + floatInterval._UseForTag(pyxb.namespace.ExpandedName(None, 'intervalStart')), + pyxb.utils.utility.Location('/home/hans/workspace/thesis/extras/schema-extended.xsd', 23, 16)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + symbol = pyxb.binding.content.ElementUse(floatInterval._UseForTag(pyxb.namespace.ExpandedName(None, 'intervalEnd')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 24, 16)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + transitions = [] + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + st_2._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) + + +floatInterval._Automaton = _BuildAutomaton() + +point._AddElement( + pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'x'), pyxb.binding.datatypes.float, scope=point, + location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 38, 12))) + +point._AddElement( + pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'y'), pyxb.binding.datatypes.float, scope=point, + location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 39, 12))) + + +def _BuildAutomaton_(): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_ + del _BuildAutomaton_ + import pyxb.utils.fac as fac + + counters = set() + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(point._UseForTag(pyxb.namespace.ExpandedName(None, 'x')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 38, 12)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + symbol = pyxb.binding.content.ElementUse(point._UseForTag(pyxb.namespace.ExpandedName(None, 'y')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 39, 12)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + st_1._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) + + +point._Automaton = _BuildAutomaton_() + +rectangle._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'length'), distance, scope=rectangle, + location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 57, 12))) + +rectangle._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'width'), distance, scope=rectangle, + location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 58, 12))) + +rectangle._AddElement( + pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'orientation'), pyxb.binding.datatypes.float, + scope=rectangle, location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 59, 12))) + +rectangle._AddElement( + pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'centerPoint'), point, scope=rectangle, + location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 60, 12))) + + +def _BuildAutomaton_2(): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_2 + del _BuildAutomaton_2 + import pyxb.utils.fac as fac + + counters = set() + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(rectangle._UseForTag(pyxb.namespace.ExpandedName(None, 'length')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 57, 12)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(rectangle._UseForTag(pyxb.namespace.ExpandedName(None, 'width')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 58, 12)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = None + symbol = pyxb.binding.content.ElementUse(rectangle._UseForTag(pyxb.namespace.ExpandedName(None, 'orientation')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 59, 12)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + symbol = pyxb.binding.content.ElementUse(rectangle._UseForTag(pyxb.namespace.ExpandedName(None, 'centerPoint')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 60, 12)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + ])) + st_2._set_transitionSet(transitions) + transitions = [] + st_3._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) + + +rectangle._Automaton = _BuildAutomaton_2() + +circle._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'radius'), distance, scope=circle, + location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 76, 12))) + +circle._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'centerPoint'), point, scope=circle, + location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 77, 12))) + + +def _BuildAutomaton_3(): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_3 + del _BuildAutomaton_3 + import pyxb.utils.fac as fac + + counters = set() + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(circle._UseForTag(pyxb.namespace.ExpandedName(None, 'radius')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 76, 12)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + symbol = pyxb.binding.content.ElementUse(circle._UseForTag(pyxb.namespace.ExpandedName(None, 'centerPoint')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 77, 12)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + st_1._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) + + +circle._Automaton = _BuildAutomaton_3() + +polygon._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'point'), point, scope=polygon, + location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 101, 12))) + + +def _BuildAutomaton_4(): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_4 + del _BuildAutomaton_4 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=3, max=None, metadata=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 101, 12)) + counters.add(cc_0) + states = [] + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(polygon._UseForTag(pyxb.namespace.ExpandedName(None, 'point')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 101, 12)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True)])) + st_0._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) + + +polygon._Automaton = _BuildAutomaton_4() + +shape._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'rectangle'), rectangle, scope=shape, + location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 119, 12))) + +shape._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'circle'), circle, scope=shape, + location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 120, 12))) + +shape._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'polygon'), polygon, scope=shape, + location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 121, 12))) + + +def _BuildAutomaton_5(): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_5 + del _BuildAutomaton_5 + import pyxb.utils.fac as fac + + counters = set() + states = [] + final_update = set() + symbol = pyxb.binding.content.ElementUse(shape._UseForTag(pyxb.namespace.ExpandedName(None, 'rectangle')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 119, 12)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + symbol = pyxb.binding.content.ElementUse(shape._UseForTag(pyxb.namespace.ExpandedName(None, 'circle')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 120, 12)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + symbol = pyxb.binding.content.ElementUse(shape._UseForTag(pyxb.namespace.ExpandedName(None, 'polygon')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 121, 12)) + st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + transitions = [] + transitions.append(fac.Transition(st_0, [ + ])) + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_0, [ + ])) + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_0, [ + ])) + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + st_2._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) + + +shape._Automaton = _BuildAutomaton_5() + +occupancy._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'shape'), shape, scope=occupancy, + location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 127, + 12))) + +occupancy._AddElement( + pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'time'), floatInterval, scope=occupancy, + location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 128, 12))) + + +def _BuildAutomaton_6(): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_6 + del _BuildAutomaton_6 + import pyxb.utils.fac as fac + + counters = set() + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(occupancy._UseForTag(pyxb.namespace.ExpandedName(None, 'shape')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 127, 12)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + symbol = pyxb.binding.content.ElementUse(occupancy._UseForTag(pyxb.namespace.ExpandedName(None, 'time')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 128, 12)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + st_1._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) + + +occupancy._Automaton = _BuildAutomaton_6() + +state._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'position'), CTD_ANON, scope=state, + location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 134, 12))) + +state._AddElement( + pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'orientation'), floatInterval, scope=state, + location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 146, 12))) + +state._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'time'), floatInterval, scope=state, + location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 147, 12))) + +state._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'velocity'), floatInterval, scope=state, + location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 148, 12))) + +state._AddElement( + pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'acceleration'), floatInterval, scope=state, + location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 149, 12))) + + +def _BuildAutomaton_7(): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_7 + del _BuildAutomaton_7 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 148, 12)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 149, 12)) + counters.add(cc_1) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(state._UseForTag(pyxb.namespace.ExpandedName(None, 'position')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 134, 12)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(state._UseForTag(pyxb.namespace.ExpandedName(None, 'orientation')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 146, 12)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + symbol = pyxb.binding.content.ElementUse(state._UseForTag(pyxb.namespace.ExpandedName(None, 'time')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 147, 12)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(state._UseForTag(pyxb.namespace.ExpandedName(None, 'velocity')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 148, 12)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(state._UseForTag(pyxb.namespace.ExpandedName(None, 'acceleration')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 149, 12)) + st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_4) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + ])) + transitions.append(fac.Transition(st_4, [ + ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_0, True)])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_0, False)])) + st_3._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_1, True)])) + st_4._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) + + +state._Automaton = _BuildAutomaton_7() + +CTD_ANON._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'point'), point, scope=CTD_ANON, + location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 137, 24))) + +CTD_ANON._AddElement( + pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'rectangle'), rectangle, scope=CTD_ANON, + location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 139, 28))) + +CTD_ANON._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'circle'), circle, scope=CTD_ANON, + location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 140, 28))) + +CTD_ANON._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'polygon'), polygon, scope=CTD_ANON, + location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 141, 28))) + + +def _BuildAutomaton_8(): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_8 + del _BuildAutomaton_8 + import pyxb.utils.fac as fac + + counters = set() + states = [] + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON._UseForTag(pyxb.namespace.ExpandedName(None, 'point')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 137, 24)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON._UseForTag(pyxb.namespace.ExpandedName(None, 'rectangle')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 139, 28)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON._UseForTag(pyxb.namespace.ExpandedName(None, 'circle')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 140, 28)) + st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON._UseForTag(pyxb.namespace.ExpandedName(None, 'polygon')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 141, 28)) + st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + transitions = [] + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + transitions.append(fac.Transition(st_3, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + transitions.append(fac.Transition(st_3, [ + ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + transitions.append(fac.Transition(st_3, [ + ])) + st_3._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) + + +CTD_ANON._Automaton = _BuildAutomaton_8() + +obstacle._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'role'), obstacleRole, scope=obstacle, + location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 181, 12))) + +obstacle._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'type'), obstacleType, scope=obstacle, + location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 182, 12))) + +obstacle._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'shape'), shape, scope=obstacle, + location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 183, 12))) + +obstacle._AddElement( + pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'trajectory'), CTD_ANON_, scope=obstacle, + location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 185, 16))) + +obstacle._AddElement( + pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'occupancySet'), CTD_ANON_2, scope=obstacle, + location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 193, 16))) + + +def _BuildAutomaton_9(): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_9 + del _BuildAutomaton_9 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 184, 12)) + counters.add(cc_0) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(obstacle._UseForTag(pyxb.namespace.ExpandedName(None, 'role')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 181, 12)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(obstacle._UseForTag(pyxb.namespace.ExpandedName(None, 'type')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 182, 12)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + symbol = pyxb.binding.content.ElementUse(obstacle._UseForTag(pyxb.namespace.ExpandedName(None, 'shape')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 183, 12)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(obstacle._UseForTag(pyxb.namespace.ExpandedName(None, 'trajectory')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 185, 16)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(obstacle._UseForTag(pyxb.namespace.ExpandedName(None, 'occupancySet')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 193, 16)) + st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_4) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + ])) + transitions.append(fac.Transition(st_4, [ + ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_0, True)])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_0, True)])) + st_3._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + fac.UpdateInstruction(cc_0, True)])) + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_0, True)])) + st_4._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) + + +obstacle._Automaton = _BuildAutomaton_9() + +CTD_ANON_._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'state'), state, scope=CTD_ANON_, + location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 188, + 28))) + + +def _BuildAutomaton_10(): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_10 + del _BuildAutomaton_10 + import pyxb.utils.fac as fac + + counters = set() + states = [] + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_._UseForTag(pyxb.namespace.ExpandedName(None, 'state')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 188, 28)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + transitions = [] + transitions.append(fac.Transition(st_0, [ + ])) + st_0._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) + + +CTD_ANON_._Automaton = _BuildAutomaton_10() + +CTD_ANON_2._AddElement( + pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'occupancy'), occupancy, scope=CTD_ANON_2, + location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 196, 28))) + + +def _BuildAutomaton_11(): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_11 + del _BuildAutomaton_11 + import pyxb.utils.fac as fac + + counters = set() + states = [] + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_2._UseForTag(pyxb.namespace.ExpandedName(None, 'occupancy')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 196, 28)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + transitions = [] + transitions.append(fac.Transition(st_0, [ + ])) + st_0._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) + + +CTD_ANON_2._Automaton = _BuildAutomaton_11() + +boundary._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'point'), point, scope=boundary, + location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 215, 12))) + +boundary._AddElement( + pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'lineMarking'), lineMarking, scope=boundary, + location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 217, 12))) + + +def _BuildAutomaton_12(): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_12 + del _BuildAutomaton_12 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 217, 12)) + counters.add(cc_0) + states = [] + final_update = set() + symbol = pyxb.binding.content.ElementUse(boundary._UseForTag(pyxb.namespace.ExpandedName(None, 'point')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 215, 12)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(boundary._UseForTag(pyxb.namespace.ExpandedName(None, 'lineMarking')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 217, 12)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + transitions = [] + transitions.append(fac.Transition(st_0, [ + ])) + transitions.append(fac.Transition(st_1, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, True)])) + st_1._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) + + +boundary._Automaton = _BuildAutomaton_12() + +laneletRefList._AddElement( + pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'lanelet'), laneletRef, scope=laneletRefList, + location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 229, 12))) + + +def _BuildAutomaton_13(): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_13 + del _BuildAutomaton_13 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 229, 12)) + counters.add(cc_0) + states = [] + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(laneletRefList._UseForTag(pyxb.namespace.ExpandedName(None, 'lanelet')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 229, 12)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True)])) + st_0._set_transitionSet(transitions) + return fac.Automaton(states, counters, True, containing_state=None) + + +laneletRefList._Automaton = _BuildAutomaton_13() + +lanelet._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'type'), laneletType, scope=lanelet, + location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 257, 12), + unicode_default='road')) + +lanelet._AddElement( + pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'isStart'), pyxb.binding.datatypes.boolean, + scope=lanelet, location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 258, 12))) + +lanelet._AddElement( + pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'leftBoundary'), boundary, scope=lanelet, + location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 259, 12))) + +lanelet._AddElement( + pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'rightBoundary'), boundary, scope=lanelet, + location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 260, 12))) + +lanelet._AddElement( + pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'predecessor'), laneletRefList, scope=lanelet, + location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 261, 12))) + +lanelet._AddElement( + pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'successor'), laneletRefList, scope=lanelet, + location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 263, 12))) + +lanelet._AddElement( + pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'adjacentLeft'), laneletAdjacentRef, scope=lanelet, + location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 265, 12))) + +lanelet._AddElement( + pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'adjacentRight'), laneletAdjacentRef, scope=lanelet, + location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 267, 12))) + +lanelet._AddElement( + pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'stopLine'), lineMarking, scope=lanelet, + location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 270, 12))) + + +def _BuildAutomaton_14(): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_14 + del _BuildAutomaton_14 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 257, 12)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 258, 12)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 261, 12)) + counters.add(cc_2) + cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 263, 12)) + counters.add(cc_3) + cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 265, 12)) + counters.add(cc_4) + cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 267, 12)) + counters.add(cc_5) + cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 270, 12)) + counters.add(cc_6) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(lanelet._UseForTag(pyxb.namespace.ExpandedName(None, 'type')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 257, 12)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(lanelet._UseForTag(pyxb.namespace.ExpandedName(None, 'isStart')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 258, 12)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = None + symbol = pyxb.binding.content.ElementUse(lanelet._UseForTag(pyxb.namespace.ExpandedName(None, 'leftBoundary')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 259, 12)) + st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + symbol = pyxb.binding.content.ElementUse(lanelet._UseForTag(pyxb.namespace.ExpandedName(None, 'rightBoundary')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 260, 12)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_2, False)) + symbol = pyxb.binding.content.ElementUse(lanelet._UseForTag(pyxb.namespace.ExpandedName(None, 'predecessor')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 261, 12)) + st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_4) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_3, False)) + symbol = pyxb.binding.content.ElementUse(lanelet._UseForTag(pyxb.namespace.ExpandedName(None, 'successor')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 263, 12)) + st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_5) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_4, False)) + symbol = pyxb.binding.content.ElementUse(lanelet._UseForTag(pyxb.namespace.ExpandedName(None, 'adjacentLeft')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 265, 12)) + st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_6) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_5, False)) + symbol = pyxb.binding.content.ElementUse(lanelet._UseForTag(pyxb.namespace.ExpandedName(None, 'adjacentRight')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 267, 12)) + st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_7) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_6, False)) + symbol = pyxb.binding.content.ElementUse(lanelet._UseForTag(pyxb.namespace.ExpandedName(None, 'stopLine')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 270, 12)) + st_8 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_8) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True)])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False)])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False)])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_1, True)])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, False)])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + ])) + transitions.append(fac.Transition(st_5, [ + ])) + transitions.append(fac.Transition(st_6, [ + ])) + transitions.append(fac.Transition(st_7, [ + ])) + transitions.append(fac.Transition(st_8, [ + ])) + st_3._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + fac.UpdateInstruction(cc_2, True)])) + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_2, False)])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_2, False)])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_2, False)])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_2, False)])) + st_4._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_5, [ + fac.UpdateInstruction(cc_3, True)])) + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_3, False)])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_3, False)])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_3, False)])) + st_5._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_4, True)])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_4, False)])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_4, False)])) + st_6._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_5, True)])) + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_5, False)])) + st_7._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_8, [ + fac.UpdateInstruction(cc_6, True)])) + st_8._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) + + +lanelet._Automaton = _BuildAutomaton_14() + +egoVehicle._AddElement( + pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'type'), obstacleType, scope=egoVehicle, + location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 277, 12))) + +egoVehicle._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'shape'), shape, scope=egoVehicle, + location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 278, + 12))) + +egoVehicle._AddElement( + pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'initialState'), state, scope=egoVehicle, + location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 279, 12))) + +egoVehicle._AddElement( + pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'goalRegion'), CTD_ANON_3, scope=egoVehicle, + location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 280, 12))) + + +def _BuildAutomaton_15(): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_15 + del _BuildAutomaton_15 + import pyxb.utils.fac as fac + + counters = set() + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(egoVehicle._UseForTag(pyxb.namespace.ExpandedName(None, 'type')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 277, 12)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(egoVehicle._UseForTag(pyxb.namespace.ExpandedName(None, 'shape')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 278, 12)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = None + symbol = pyxb.binding.content.ElementUse(egoVehicle._UseForTag(pyxb.namespace.ExpandedName(None, 'initialState')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 279, 12)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + symbol = pyxb.binding.content.ElementUse(egoVehicle._UseForTag(pyxb.namespace.ExpandedName(None, 'goalRegion')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 280, 12)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_3, [ + ])) + st_2._set_transitionSet(transitions) + transitions = [] + st_3._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) + + +egoVehicle._Automaton = _BuildAutomaton_15() + +CTD_ANON_3._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'state'), state, scope=CTD_ANON_3, + location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 283, + 24))) + + +def _BuildAutomaton_16(): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_16 + del _BuildAutomaton_16 + import pyxb.utils.fac as fac + + counters = set() + states = [] + final_update = set() + symbol = pyxb.binding.content.ElementUse(CTD_ANON_3._UseForTag(pyxb.namespace.ExpandedName(None, 'state')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 283, 24)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + transitions = [] + transitions.append(fac.Transition(st_0, [ + ])) + st_0._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) + + +CTD_ANON_3._Automaton = _BuildAutomaton_16() + +parkingLot._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'shape'), shape, scope=parkingLot, + location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 295, + 12))) + + +def _BuildAutomaton_17(): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_17 + del _BuildAutomaton_17 + import pyxb.utils.fac as fac + + counters = set() + states = [] + final_update = set() + symbol = pyxb.binding.content.ElementUse(parkingLot._UseForTag(pyxb.namespace.ExpandedName(None, 'shape')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 295, 12)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + transitions = [] + st_0._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) + + +parkingLot._Automaton = _BuildAutomaton_17() + +trafficSign._AddElement( + pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'type'), STD_ANON, scope=trafficSign, + location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 303, 12))) + +trafficSign._AddElement( + pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'orientation'), pyxb.binding.datatypes.float, + scope=trafficSign, location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 324, 12))) + +trafficSign._AddElement( + pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'centerPoint'), point, scope=trafficSign, + location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 325, 12))) + + +def _BuildAutomaton_18(): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_18 + del _BuildAutomaton_18 + import pyxb.utils.fac as fac + + counters = set() + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(trafficSign._UseForTag(pyxb.namespace.ExpandedName(None, 'type')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 303, 12)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(trafficSign._UseForTag(pyxb.namespace.ExpandedName(None, 'orientation')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 324, 12)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + symbol = pyxb.binding.content.ElementUse(trafficSign._UseForTag(pyxb.namespace.ExpandedName(None, 'centerPoint')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 325, 12)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + st_2._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) + + +trafficSign._Automaton = _BuildAutomaton_18() + +intersection._AddElement( + pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'composition'), laneletRefList, scope=intersection, + location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 333, 12))) + +intersection._AddElement( + pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'priority'), CTD_ANON_4, scope=intersection, + location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 334, 12))) + + +def _BuildAutomaton_19(): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_19 + del _BuildAutomaton_19 + import pyxb.utils.fac as fac + + counters = set() + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(intersection._UseForTag(pyxb.namespace.ExpandedName(None, 'composition')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 333, 12)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + symbol = pyxb.binding.content.ElementUse(intersection._UseForTag(pyxb.namespace.ExpandedName(None, 'priority')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 334, 12)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + st_1._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) + + +intersection._Automaton = _BuildAutomaton_19() + +CommonRoad._AddElement( + pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'obstacle'), obstacle, scope=CommonRoad, + location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 346, 12))) + +CommonRoad._AddElement( + pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'lanelet'), lanelet, scope=CommonRoad, + location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 348, 12))) + +CommonRoad._AddElement( + pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'egoVehicle'), egoVehicle, scope=CommonRoad, + location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 350, 12))) + +CommonRoad._AddElement( + pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'parkingLot'), parkingLot, scope=CommonRoad, + location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 352, 12))) + +CommonRoad._AddElement( + pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'trafficSign'), trafficSign, scope=CommonRoad, + location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 354, 12))) + +CommonRoad._AddElement( + pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'intersection'), intersection, scope=CommonRoad, + location=pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 356, 12))) + + +def _BuildAutomaton_20(): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_20 + del _BuildAutomaton_20 + import pyxb.utils.fac as fac + + counters = set() + states = [] + final_update = set() + symbol = pyxb.binding.content.ElementUse(CommonRoad._UseForTag(pyxb.namespace.ExpandedName(None, 'obstacle')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 346, 12)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CommonRoad._UseForTag(pyxb.namespace.ExpandedName(None, 'lanelet')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 348, 12)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CommonRoad._UseForTag(pyxb.namespace.ExpandedName(None, 'egoVehicle')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 350, 12)) + st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CommonRoad._UseForTag(pyxb.namespace.ExpandedName(None, 'parkingLot')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 352, 12)) + st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CommonRoad._UseForTag(pyxb.namespace.ExpandedName(None, 'trafficSign')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 354, 12)) + st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_4) + final_update = set() + symbol = pyxb.binding.content.ElementUse(CommonRoad._UseForTag(pyxb.namespace.ExpandedName(None, 'intersection')), + pyxb.utils.utility.Location( + '/home/hans/workspace/thesis/extras/schema-extended.xsd', 356, 12)) + st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_5) + transitions = [] + transitions.append(fac.Transition(st_0, [ + ])) + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + transitions.append(fac.Transition(st_3, [ + ])) + transitions.append(fac.Transition(st_4, [ + ])) + transitions.append(fac.Transition(st_5, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_0, [ + ])) + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + transitions.append(fac.Transition(st_3, [ + ])) + transitions.append(fac.Transition(st_4, [ + ])) + transitions.append(fac.Transition(st_5, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_0, [ + ])) + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + transitions.append(fac.Transition(st_3, [ + ])) + transitions.append(fac.Transition(st_4, [ + ])) + transitions.append(fac.Transition(st_5, [ + ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_0, [ + ])) + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + transitions.append(fac.Transition(st_3, [ + ])) + transitions.append(fac.Transition(st_4, [ + ])) + transitions.append(fac.Transition(st_5, [ + ])) + st_3._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_0, [ + ])) + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + transitions.append(fac.Transition(st_3, [ + ])) + transitions.append(fac.Transition(st_4, [ + ])) + transitions.append(fac.Transition(st_5, [ + ])) + st_4._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_0, [ + ])) + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + transitions.append(fac.Transition(st_3, [ + ])) + transitions.append(fac.Transition(st_4, [ + ])) + transitions.append(fac.Transition(st_5, [ + ])) + st_5._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) + + +CommonRoad._Automaton = _BuildAutomaton_20() + diff --git a/commonroad/utils.py b/commonroad/utils.py old mode 100644 new mode 100755 diff --git a/gazebo-renderer.py b/gazebo-renderer.py index be290b0..7009317 100755 --- a/gazebo-renderer.py +++ b/gazebo-renderer.py @@ -9,6 +9,7 @@ default=sys.stdin) parser.add_argument("--output", "-o", required=True) parser.add_argument("--force", "-f", action="store_true") + parser.add_argument("--add_vehicle", "-av", action="store_true") args = parser.parse_args() os.makedirs(args.output, exist_ok=True) @@ -20,4 +21,4 @@ with args.input as input_file: xml = input_file.read() - sdf.generate_sdf(xml, args.output) + sdf.generate_sdf(xml, args.output, args.add_vehicle) diff --git a/generate_blender_env.sh b/generate_blender_env.sh new file mode 100644 index 0000000..a5f663c --- /dev/null +++ b/generate_blender_env.sh @@ -0,0 +1 @@ +blender -b -P blender-renderer.py \ No newline at end of file diff --git a/generated-roads/road-driving-extended.xml b/generated-roads/road-driving-extended.xml old mode 100644 new mode 100755 diff --git a/generated-roads/road-driving.xml b/generated-roads/road-driving.xml old mode 100644 new mode 100755 diff --git a/generated-roads/road-parking.xml b/generated-roads/road-parking.xml old mode 100644 new mode 100755 diff --git a/keyframe_plugin/CMakeLists.txt b/keyframe_plugin/CMakeLists.txt old mode 100644 new mode 100755 diff --git a/keyframe_plugin/keyframes.cc b/keyframe_plugin/keyframes.cc old mode 100644 new mode 100755 diff --git a/old/commonroad.py b/old/commonroad.py old mode 100644 new mode 100755 diff --git a/old/parser.py b/old/parser.py old mode 100644 new mode 100755 diff --git a/presets/driving.xml b/presets/driving.xml old mode 100644 new mode 100755 diff --git a/presets/driving_extended.xml b/presets/driving_extended.xml old mode 100644 new mode 100755 index dd45dfc..a3c8114 --- a/presets/driving_extended.xml +++ b/presets/driving_extended.xml @@ -14,6 +14,8 @@ + + @@ -23,10 +25,14 @@ - + + + + + @@ -60,6 +66,9 @@ + + + @@ -69,9 +78,27 @@