def from_xodr(xodr_file, sample_distance=0.25): xodr_string = "" with open(xodr_file, "r") as f: xodr_string = f.read() map_name = xodr_file.split(".")[0] carla_map = carla.Map(map_name, xodr_string) return OpenDriveManager(carla_map, sample_distance)
def map_from_opendrive(opendrive: str, log_file_name: str = None): try: import carla except ImportError: raise Exception('Error importing carla.') from pylot.map.hd_map import HDMap return HDMap(carla.Map('map', opendrive), log_file_name)
def on_open_drive_map(self, msg): self._logger.debug('@{}: open drive update'.format(msg.timestamp)) try: import carla except ImportError: raise Exception('Error importing carla.') self._map = HDMap(carla.Map('challenge', msg.data), self._log_file_name)
def main(): with open('Town01.xodr', 'r') as file: data = file.read() #print(data) map = carla.Map("Town01", data) print(map.transform_to_geolocation(carla.Location(0,0,0))) wp1 = map.get_waypoint(carla.Location(0,0,0)) print(wp1) print(f"road_id: {wp1.road_id}, section_id: {wp1.section_id}, lane_id: {wp1.lane_id}, is_junction: {wp1.is_junction}") print(wp1.next(1)[0])
def on_opendrive_map(self, msg): """Invoked whenever a message is received on the open drive stream. Args: msg (:py:class:`~erdos.message.Message`): Message that contains the open drive string. """ self._logger.debug('@{}: received open drive message'.format( msg.timestamp)) try: import carla except ImportError: raise Exception('Error importing carla.') self._logger.info('Initializing HDMap from open drive stream') from pylot.map.hd_map import HDMap self._map = HDMap(carla.Map('map', msg.data))
def build_binary_for_tm(package_name, dirname, maps): xodrs = set((map["name"], map["xodr"]) for map in maps if "xodr" in map) for target_name, xodr in xodrs: with open(os.path.join(dirname, xodr), "rt") as f: data = f.read() # copy the binary file tm_folder_target = os.path.join(CARLA_ROOT_PATH, "Unreal", "CarlaUE4", "Content", package_name, "Maps", target_name, "TM") if not os.path.exists(tm_folder_target): os.makedirs(tm_folder_target) m = carla.Map(str(target_name), data) m.cook_in_memory_map( str(os.path.join(tm_folder_target, "%s.bin" % target_name)))
def _netconvert_carla_impl(xodr_file, output, tmpdir, guess_tls=False): """ Implements netconvert carla. """ # ---------- # netconvert # ---------- basename = os.path.splitext(os.path.basename(xodr_file))[0] tmp_sumo_net = os.path.join(tmpdir, basename + '.net.xml') try: basedir = os.path.dirname(os.path.realpath(__file__)) result = subprocess.call(['netconvert', '--opendrive', xodr_file, '--output-file', tmp_sumo_net, '--geometry.min-radius.fix', '--geometry.remove', '--opendrive.curve-resolution', '1', '--opendrive.import-all-lanes', '--type-files', os.path.join(basedir, 'data/opendrive_netconvert.typ.xml'), # Necessary to link odr and sumo ids. '--output.original-names', # Discard loading traffic lights as them will be inserted manually afterwards. '--tls.discard-loaded', 'true', ]) except subprocess.CalledProcessError: raise RuntimeError('There was an error when executing netconvert.') else: if result != 0: raise RuntimeError('There was an error when executing netconvert.') # -------- # Sumo net # -------- sumo_net = sumolib.net.readNet(tmp_sumo_net) sumo_topology = build_topology(sumo_net) # --------- # Carla map # --------- with open(xodr_file, 'r') as f: carla_map = carla.Map('netconvert', str(f.read())) # --------- # Landmarks # --------- tls = {} # {tlsid: SumoTrafficLight} landmarks = carla_map.get_all_landmarks_of_type('1000001') for landmark in landmarks: if landmark.name == '': # This is a workaround to avoid adding traffic lights without controllers. logging.warning('Landmark %s has not a valid name.', landmark.name) continue road_id = str(landmark.road_id) for from_lane, to_lane in landmark.get_lane_validities(): for lane_id in range(from_lane, to_lane + 1): if lane_id == 0: continue wp = carla_map.get_waypoint_xodr(landmark.road_id, lane_id, landmark.s) if wp is None: logging.warning( 'Could not find waypoint for landmark {} (road_id: {}, lane_id: {}, s:{}'. format(landmark.id, landmark.road_id, lane_id, landmark.s)) continue # When the landmark belongs to a junction, we place te traffic light at the # entrance of the junction. if wp.is_junction and sumo_topology.is_junction(road_id, lane_id): tlid = str(wp.get_junction().id) if tlid not in tls: tls[tlid] = SumoTrafficLight(tlid) tl = tls[tlid] if guess_tls: for from_edge, from_lane in sumo_topology.get_incoming(road_id, lane_id): successors = sumo_topology.get_successors(from_edge, from_lane) for to_edge, to_lane in successors: tl.add_landmark(landmark.id, tl.id, from_edge, to_edge, from_lane, to_lane) else: connections = sumo_topology.get_path_connectivity(road_id, lane_id) for from_, to_ in connections: from_edge, from_lane = from_ to_edge, to_lane = to_ tl.add_landmark(landmark.id, tl.id, from_edge, to_edge, from_lane, to_lane) # When the landmarks does not belong to a junction (i.e., belongs to a std road), # we place the traffic light between that std road and its successor. elif not wp.is_junction and not sumo_topology.is_junction(road_id, lane_id): from_edge, from_lane = sumo_topology.get_sumo_id(road_id, lane_id, landmark.s) for to_edge, to_lane in sumo_topology.get_successors(from_edge, from_lane): tlid = SumoTrafficLight.generate_tl_id(from_edge, to_edge) if tlid not in tls: tls[tlid] = SumoTrafficLight(tlid) tl = tls[tlid] tl.add_landmark(landmark.id, tl.id, from_edge, to_edge, from_lane, to_lane) else: logging.warning('Landmark %s could not be added.', landmark.id) # --------------- # Modify sumo net # --------------- parser = ET.XMLParser(remove_blank_text=True) tree = ET.parse(tmp_sumo_net, parser) root = tree.getroot() for tl in tls.values(): SumoTrafficLight.generate_default_program(tl) edges_tags = tree.xpath('//edge') if not edges_tags: raise RuntimeError('No edges found in sumo net.') root.insert(root.index(edges_tags[-1]) + 1, tl.to_xml()) for connection in tl.connections: tags = tree.xpath( '//connection[@from="{}" and @to="{}" and @fromLane="{}" and @toLane="{}"]'.format( connection.from_road, connection.to_road, connection.from_lane, connection.to_lane)) if tags: if len(tags) > 1: logging.warning( 'Found repeated connections from={} to={} fromLane={} toLane={}.'.format( connection.from_road, connection.to_road, connection.from_lane, connection.to_lane)) tags[0].set('tl', str(connection.tlid)) tags[0].set('linkIndex', str(connection.link_index)) else: logging.warning('Not found connection from={} to={} fromLane={} toLane={}.'.format( connection.from_road, connection.to_road, connection.from_lane, connection.to_lane)) tree.write(output, pretty_print=True, encoding='UTF-8', xml_declaration=True)
def on_opendrive_map(self, msg): self._map = HDMap(carla.Map('challenge', msg.data), self._log_file_name)
def load_map(xodr_file): with open(xodr_file, 'r') as f: carla_map = carla.Map('odr2lanelet2', str(f.read())) return OdrMap(carla_map)
def on_open_drive_map(self, msg): self._logger.debug('@{}: open drive update'.format(msg.timestamp)) self._map = HDMap(carla.Map('challenge', msg.data), self._log_file_name)
def on_opendrive_map(self, msg): self._logger.debug('@{}: received open drive message'.format( msg.timestamp)) self._logger.info('Initializing HDMap from open drive stream') self._map = HDMap(carla.Map('map', msg.data), self._log_file_name)
def on_opendrive_map(self, msg): self._logger.info('Planner running in scenario runner mode') self._map = HDMap(carla.Map('map', msg.data), self._log_file_name)
type=str, help='OpenDRIVE file') args = argparser.parse_args() # read the OpenDRIVE try: f = open(args.file, "rt") except: print("OpenDRIVE file not found!") exit(1) data = f.read() f.close() # create the map with the OpenDRIVE content m = carla.Map("t", data) points = m.get_crosswalks() for i in range(len(points)): print(points[i]) # generate the .OBJ file f = open("crosswalks.obj", "wt") faceIndex = 0 vertexIndex = 0 i = 0 totalCrosswalks = 0 totalPoints = 0 while (i < len(points)): totalCrosswalks += 1 # object f.write("o crosswalk_%d\n" % totalCrosswalks)