sumolib.net

   1# Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
   2# Copyright (C) 2008-2026 German Aerospace Center (DLR) and others.
   3# This program and the accompanying materials are made available under the
   4# terms of the Eclipse Public License 2.0 which is available at
   5# https://www.eclipse.org/legal/epl-2.0/
   6# This Source Code may also be made available under the following Secondary
   7# Licenses when the conditions for such availability set forth in the Eclipse
   8# Public License 2.0 are satisfied: GNU General Public License, version 2
   9# or later which is available at
  10# https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
  11# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
  12
  13# @file    __init__.py
  14# @author  Daniel Krajzewicz
  15# @author  Laura Bieker
  16# @author  Karol Stosiek
  17# @author  Michael Behrisch
  18# @author  Jakob Erdmann
  19# @author  Robert Hilbrich
  20# @author  Mirko Barthauer
  21# @date    2008-03-27
  22
  23"""
  24This file contains a content handler for parsing sumo network xml files.
  25It uses other classes from this module to represent the road network.
  26"""
  27
  28from __future__ import print_function
  29from __future__ import absolute_import
  30import sys
  31import math
  32import heapq
  33import gzip
  34import warnings
  35import io
  36from xml.sax import handler, parse
  37from copy import copy
  38from collections import defaultdict
  39from itertools import chain
  40try:
  41    from functools import lru_cache
  42    HAVE_LRU_CACHE = True
  43except ImportError:
  44    HAVE_LRU_CACHE = False
  45
  46try:
  47    import lxml.etree
  48    import pathlib
  49    HAVE_LXML = True
  50except ImportError:
  51    HAVE_LXML = False
  52
  53try:
  54    import pyproj  # noqa
  55    HAVE_PYPROJ = True
  56except ImportError:
  57    HAVE_PYPROJ = False
  58
  59import sumolib
  60from . import lane, edge, netshiftadaptor, node, connection, roundabout  # noqa
  61from .connection import Connection
  62from sumolib.miscutils import intIfPossible, openz, PRACTICAL_INFINITY
  63from sumolib.miscutils import benchmark_cumulative  # noqa
  64
  65
  66class TLS:
  67
  68    """Traffic Light Signal for a sumo network"""
  69
  70    def __init__(self, id):
  71        self._id = id
  72        self._connections = []
  73        self._maxConnectionNo = -1
  74        self._programs = {}
  75
  76    def addConnection(self, inLane, outLane, linkNo):
  77        self._connections.append([inLane, outLane, linkNo])
  78        if linkNo > self._maxConnectionNo:
  79            self._maxConnectionNo = linkNo
  80
  81    def getConnections(self):
  82        return self._connections
  83
  84    def getID(self):
  85        return self._id
  86
  87    def getLinks(self):
  88        links = {}
  89        for the_connection in self._connections:
  90            if the_connection[2] not in links:
  91                links[the_connection[2]] = []
  92            links[the_connection[2]].append(the_connection)
  93        return links
  94
  95    def getEdges(self):
  96        edges = set()
  97        for c in self._connections:
  98            edges.add(c[0].getEdge())
  99        return edges
 100
 101    def addProgram(self, program):
 102        self._programs[program._id] = program
 103
 104    def removePrograms(self):
 105        self._programs.clear()
 106
 107    def toXML(self):
 108        ret = ""
 109        for p in self._programs:
 110            ret = ret + self._programs[p].toXML(self._id)
 111        return ret
 112
 113    def getPrograms(self):
 114        return self._programs
 115
 116
 117class Phase:
 118
 119    def __init__(self, duration, state, minDur=None, maxDur=None, next=tuple(), name="", earlyTarget=""):
 120        """
 121        Constructs a traffic light phase
 122        duration (float): the duration of the phase in seconds
 123        state (string): the state codes for each controlled link
 124        minDur (float): the minimum duration (ignored by static tls)
 125        maxDur (float): the maximum duration (ignored by static tls)
 126        next (intList): possible succesor phase (optional)
 127        name (string): the name of the phase
 128        earlyTarget (string): early switching to phase with the given index(es)
 129        """
 130        self.duration = duration
 131        self.state = state
 132        # minimum and maximum duration (only for actuated tls)
 133        self.minDur = minDur if minDur is not None else duration
 134        self.maxDur = maxDur if maxDur is not None else duration
 135        self.next = next
 136        self.name = name
 137        self.earlyTarget = earlyTarget
 138
 139    def __repr__(self):
 140        name = (", name='%s'" % self.name) if self.name else ""
 141        next = (", next='%s'" % str(self.next)) if self.next else ""
 142        earlyTarget = (", earlyTarget='%s'" % self.earlyTarget) if self.earlyTarget else ""
 143        return ("Phase(duration=%s, state='%s', minDur=%s, maxDur=%s%s%s%s)"
 144                % (self.duration, self.state, self.minDur, self.maxDur, name, next, earlyTarget))
 145
 146
 147class TLSProgram:
 148
 149    def __init__(self, id, offset, type):
 150        self._id = id
 151        self._type = type
 152        self._offset = offset
 153        self._phases = []
 154        self._params = {}
 155        self._conditions = {}
 156
 157    def addPhase(self, state, duration, minDur=-1, maxDur=-1, next=None, name="", earlyTarget=""):
 158        self._phases.append(Phase(duration, state, minDur, maxDur, next, name, earlyTarget))
 159
 160    def addCondition(self, id, value):
 161        self._conditions[id] = value
 162
 163    def toXML(self, tlsID):
 164        ret = '  <tlLogic id="%s" type="%s" programID="%s" offset="%s">\n' % (
 165            tlsID, self._type, self._id, self._offset)
 166        for p in self._phases:
 167            minDur = '' if p.minDur < 0 else ' minDur="%s"' % p.minDur
 168            maxDur = '' if p.maxDur < 0 else ' maxDur="%s"' % p.maxDur
 169            name = '' if p.name == '' else ' name="%s"' % p.name
 170            next = '' if len(p.next) == 0 else ' next="%s"' % ' '.join(map(str, p.next))
 171            earlyTarget = '' if p.earlyTarget == '' else ' earlyTarget="%s"' % p.earlyTarget
 172            ret += '    <phase duration="%s" state="%s"%s%s%s%s%s/>\n' % (
 173                p.duration, p.state, minDur, maxDur, name, next, earlyTarget)
 174        for k, v in self._params.items():
 175            ret += '    <param key="%s" value="%s"/>\n' % (k, v)
 176        for i, v in self._conditions.items():
 177            ret += '    <condition id="%s" value="%s"/>\n' % (i, v)
 178        ret += '  </tlLogic>\n'
 179        return ret
 180
 181    def getPhases(self):
 182        return self._phases
 183
 184    def getType(self):
 185        return self._type
 186
 187    def setParam(self, key, value):
 188        self._params[key] = value
 189
 190    def getParam(self, key, default=None):
 191        return self._params.get(key, default)
 192
 193    def getParams(self):
 194        return self._params
 195
 196    def getStages(self):
 197        stages = dict()
 198        for idx, phase in enumerate(self.getPhases()):
 199            if phase not in stages.values():
 200                if 'G' in phase.state and 'y' not in phase.state and phase.name:
 201                    stages[idx] = phase
 202        return stages
 203
 204    def getOffset(self):
 205        return self._offset
 206
 207
 208class EdgeType:
 209    def __init__(self, id, allow, disallow):
 210        self.id = id
 211        self.allow = allow
 212        self.disallow = disallow
 213
 214
 215class Net:
 216
 217    """The whole sumo network."""
 218
 219    def __init__(self):
 220        self._location = {}
 221        self._id2node = {}
 222        self._id2edge = {}
 223        self._crossings_and_walkingAreas = set()
 224        self._macroConnectors = set()
 225        self._id2tls = {}
 226        self._nodes = []
 227        self._edges = []
 228        self._tlss = []
 229        self._ranges = [[sys.float_info.max, -sys.float_info.max], [sys.float_info.max, -sys.float_info.max]]
 230        self._roundabouts = []
 231        self._rtreeEdges = {True: None, False: None}  # different rTrees depending on includeJunctions
 232        self._rtreeLanes = {True: None, False: None}  # different rTrees depending on includeJunctions
 233        self._allLanes = []
 234        self._origIdx = None
 235        self._proj = None
 236        self.hasInternal = False
 237        self.hasWalkingArea = False
 238        # store dijsktra heap for reuse if the same origin is used repeatedly
 239        self._shortestPathCache = None
 240        self._version = None
 241        self._edgeTypes = defaultdict(lambda: EdgeType("DEFAULT_EDGETYPE", "", ""))
 242        self._routingCache = None
 243        self._routingCacheOD = None
 244        self._edgeSuccessorCache = None
 245        self._edgeCostCache = None
 246
 247    def initRoutingCache(self, maxsize=1000):
 248        self._routingCache = lru_cache(maxsize=maxsize)(lambda fromEdge, fastest, vClass, ignoreDirection, reversalPenalty, preferences: {})  # noqa
 249
 250    def cacheRoute(self, fromEdge, toEdge, fastest, vClass, cost, path):
 251        if self._routingCacheOD is None:
 252            self._routingCacheOD = dict()
 253        self._routingCacheOD[(fromEdge, toEdge, fastest, vClass)] = (cost, path)
 254
 255    def getVersion(self):
 256        return self._version
 257
 258    def getEdgeType(self, typeID):
 259        return self._edgeTypes[typeID]
 260
 261    def setLocation(self, netOffset, convBoundary, origBoundary, projParameter):
 262        self._location["netOffset"] = netOffset
 263        self._location["convBoundary"] = convBoundary
 264        self._location["origBoundary"] = origBoundary
 265        self._location["projParameter"] = projParameter
 266
 267    def loadSelection(self, selectionFile):
 268        self.resetSelection()
 269        with io.open(selectionFile, "r", encoding="utf-8") as f:
 270            for line in f:
 271                line = line.strip()
 272                if line.startswith("edge:"):
 273                    edgeID = line[5:]
 274                    if edgeID in self._id2edge:
 275                        self.getEdge(edgeID).select()
 276                elif line.startswith("junction:"):
 277                    nodeID = line[9:]
 278                    if nodeID in self._id2node:
 279                        self.getNode(nodeID).select()
 280
 281    def resetSelection(self):
 282        for n in self._nodes:
 283            n.select(False)
 284        for e in self._edges:
 285            e.select(False)
 286
 287    def addNode(self, id, type=None, coord=None, incLanes=None, intLanes=None):
 288        if id is None:
 289            return None
 290        if id not in self._id2node:
 291            n = node.Node(id, type, coord, incLanes, intLanes)
 292            self._nodes.append(n)
 293            self._id2node[id] = n
 294        self.setAdditionalNodeInfo(
 295            self._id2node[id], type, coord, incLanes, intLanes)
 296        return self._id2node[id]
 297
 298    def setAdditionalNodeInfo(self, node, type, coord, incLanes, intLanes=None):
 299        if coord is not None and node._coord is None:
 300            node._coord = coord
 301            self._ranges[0][0] = min(self._ranges[0][0], coord[0])
 302            self._ranges[0][1] = max(self._ranges[0][1], coord[0])
 303            self._ranges[1][0] = min(self._ranges[1][0], coord[1])
 304            self._ranges[1][1] = max(self._ranges[1][1], coord[1])
 305        if incLanes is not None and node._incLanes is None:
 306            node._incLanes = incLanes
 307        if intLanes is not None and node._intLanes is None:
 308            node._intLanes = intLanes
 309        if type is not None and node._type is None:
 310            node._type = type
 311
 312    def addEdge(self, id, fromID, toID, prio, function, name, edgeType='', routingType=''):
 313        if id not in self._id2edge:
 314            fromN = self.addNode(fromID)
 315            toN = self.addNode(toID)
 316            e = edge.Edge(id, fromN, toN, prio, function, name, edgeType, routingType)
 317            self._edges.append(e)
 318            self._id2edge[id] = e
 319            if function:
 320                self.hasInternal = True
 321                if function == "walkingarea":
 322                    self.hasWalkingArea = True
 323        return self._id2edge[id]
 324
 325    def addLane(self, edge, speed, length, width, allow=None, disallow=None, acceleration=False):
 326        return lane.Lane(edge, speed, length, width, allow, disallow, acceleration)
 327
 328    def addRoundabout(self, nodes, edges=None):
 329        r = roundabout.Roundabout(nodes, edges)
 330        self._roundabouts.append(r)
 331        return r
 332
 333    def addConnection(self, fromEdge, toEdge, fromlane, tolane, direction,
 334                      tls, tllink, tllink2, allow, disallow, state, viaLaneID=None):
 335        conn = connection.Connection(
 336            fromEdge, toEdge, fromlane, tolane, direction,
 337            tls, tllink, tllink2, allow, disallow, state, viaLaneID)
 338        fromEdge.addOutgoing(conn)
 339        fromlane.addOutgoing(conn)
 340        toEdge._addIncoming(conn)
 341        if viaLaneID:
 342            try:
 343                # internal lanes are only available when building with option withInternal=True
 344                viaLane = self.getLane(viaLaneID)
 345                viaEdge = viaLane.getEdge()
 346                viaEdge._addIncoming(connection.Connection(
 347                    fromEdge, viaEdge, fromlane, viaLane, direction, tls,
 348                    tllink, tllink2, allow, disallow, state, ''))
 349            except Exception:
 350                pass
 351        return conn
 352
 353    def getEdges(self, withInternal=True):
 354        if not withInternal:
 355            return [e for e in self._edges if e.getFunction() == '']
 356        else:
 357            return self._edges
 358
 359    def getRoundabouts(self):
 360        return self._roundabouts
 361
 362    def hasEdge(self, id):
 363        return id in self._id2edge
 364
 365    def getEdge(self, id):
 366        return self._id2edge[id]
 367
 368    def getLane(self, laneID):
 369        edge_id, lane_index = laneID.rsplit("_", 1)
 370        return self.getEdge(edge_id).getLane(int(lane_index))
 371
 372    def _initRTree(self, shapeList, includeJunctions=True):
 373        import rtree  # noqa
 374        result = rtree.index.Index()
 375        result.interleaved = True
 376        for ri, shape in enumerate(shapeList):
 377            result.add(ri, shape.getBoundingBox(includeJunctions))
 378        return result
 379
 380    # Please be aware that the resulting list of edges is NOT sorted
 381    def getNeighboringEdges(self, x, y, r=0.1, includeJunctions=True, allowFallback=True):
 382        edges = []
 383        rtree = self._rtreeEdges[includeJunctions]
 384        try:
 385            if rtree is None:
 386                rtree = self._initRTree(self._edges, includeJunctions)
 387                self._rtreeEdges[includeJunctions] = rtree
 388            for i in rtree.intersection((x - r, y - r, x + r, y + r)):
 389                e = self._edges[i]
 390                d = sumolib.geomhelper.distancePointToPolygon(
 391                    (x, y), e.getShape(includeJunctions))
 392                if d < r:
 393                    edges.append((e, d))
 394        except ImportError:
 395            if not allowFallback:
 396                raise
 397            warnings.warn("Module 'rtree' not available. Using brute-force fallback.")
 398            for the_edge in self._edges:
 399                d = sumolib.geomhelper.distancePointToPolygon((x, y), the_edge.getShape(includeJunctions))
 400                if d < r:
 401                    edges.append((the_edge, d))
 402        return edges
 403
 404    def getNeighboringLanes(self, x, y, r=0.1, includeJunctions=True, allowFallback=True):
 405        lanes = []
 406        rtree = self._rtreeLanes[includeJunctions]
 407        try:
 408            if rtree is None:
 409                for the_edge in self._edges:
 410                    self._allLanes += the_edge.getLanes()
 411                rtree = self._initRTree(self._allLanes, includeJunctions)
 412                self._rtreeLanes[includeJunctions] = rtree
 413            for i in rtree.intersection((x - r, y - r, x + r, y + r)):
 414                the_lane = self._allLanes[i]
 415                d = sumolib.geomhelper.distancePointToPolygon((x, y), the_lane.getShape(includeJunctions))
 416                if d < r:
 417                    lanes.append((the_lane, d))
 418        except ImportError:
 419            if not allowFallback:
 420                raise
 421            warnings.warn("Module 'rtree' not available. Using brute-force fallback.")
 422            for the_edge in self._edges:
 423                for the_lane in the_edge.getLanes():
 424                    d = sumolib.geomhelper.distancePointToPolygon((x, y), the_lane.getShape(includeJunctions))
 425                    if d < r:
 426                        lanes.append((the_lane, d))
 427        return lanes
 428
 429    def getNearestLane(self, x, y, r=0.1, vClass=None, isGeo=False, allowFallback=True):
 430        """Return (lane, lanePos, dist) for the nearest lane at a distance less than r,
 431        or None if no lane matches. Both lanePos and dist are in meters.
 432
 433        If vClass is given, only lanes allowing that vehicle class are considered.
 434        If isGeo is True, x and y are longitude and latitude, respectively, and
 435        the network's geo-projection is used (requires pyproj).
 436        Distances are measured to the lane shape without junction extensions.
 437        Internal lanes are considered if the network was read withInternal=True.
 438        """
 439        if isGeo:
 440            x, y = self.convertLonLat2XY(x, y)
 441        candidates = [(lane, dist) for lane, dist in
 442                      self.getNeighboringLanes(x, y, r, includeJunctions=False, allowFallback=allowFallback)
 443                      if lane.allows(vClass)]
 444        if not candidates:
 445            return None
 446        lane, dist = min(candidates, key=lambda candidate: candidate[1])
 447        lanePos, dist = lane.getClosestLanePosAndDist((x, y))
 448        return lane, lanePos, dist
 449
 450    def hasNode(self, id):
 451        return id in self._id2node
 452
 453    def getNode(self, id):
 454        return self._id2node[id]
 455
 456    def getNodes(self):
 457        return self._nodes
 458
 459    def getTLS(self, tlid):
 460        return self._id2tls[tlid]
 461
 462    def getTLSSecure(self, tlid):
 463        if tlid in self._id2tls:
 464            tls = self._id2tls[tlid]
 465        else:
 466            tls = TLS(tlid)
 467            self._id2tls[tlid] = tls
 468            self._tlss.append(tls)
 469        return tls
 470
 471    def getTrafficLights(self):
 472        return self._tlss
 473
 474    def addTLS(self, tlid, inLane, outLane, linkNo):
 475        tls = self.getTLSSecure(tlid)
 476        tls.addConnection(inLane, outLane, linkNo)
 477        return tls
 478
 479    def addTLSProgram(self, tlid, programID, offset, type, removeOthers):
 480        tls = self.getTLSSecure(tlid)
 481        program = TLSProgram(programID, offset, type)
 482        if removeOthers:
 483            tls.removePrograms()
 484        tls.addProgram(program)
 485        return program
 486
 487    def setFoes(self, junctionID, index, foes, prohibits):
 488        self._id2node[junctionID].setFoes(index, foes, prohibits)
 489
 490    def forbids(self, possProhibitor, possProhibited):
 491        return possProhibitor.getFrom().getToNode().forbids(possProhibitor, possProhibited)
 492
 493    def getUpstreamEdges(self, edge, distance, stopOnTLS, stopOnTurnaround):
 494        """return a list of lists of the form
 495           [[firstEdge, pos, [edge_0, edge_1, ..., edge_k], aborted], ...]
 496           where
 497             firstEdge: is the upstream edge furthest away from the intersection,
 498             [edge_0, ..., edge_k]: is the list of edges from the intersection upstream to firstEdge
 499             pos: is the position on firstEdge with distance to the end of the input edge
 500             aborted: a flag indicating whether the downstream
 501                 search stopped at a TLS or a node without incoming edges before reaching the distance threshold
 502        """
 503        ret = []
 504        seen = set()
 505        toProc = []
 506        toProc.append([edge, 0, []])
 507        while not len(toProc) == 0:
 508            ie = toProc.pop()
 509            if ie[0] in seen:
 510                continue
 511            seen.add(ie[0])
 512            if ie[1] + ie[0].getLength() >= distance:
 513                ret.append(
 514                    [ie[0], ie[0].getLength() + ie[1] - distance, ie[2], False])
 515                continue
 516            if len(ie[0]._incoming) == 0:
 517                ret.append([ie[0], ie[0].getLength() + ie[1], ie[2], True])
 518                continue
 519            mn = []
 520            stop = False
 521            for ci in ie[0]._incoming:
 522                if ci not in seen:
 523                    prev = copy(ie[2])
 524                    if stopOnTLS and ci._tls and ci != edge and not stop:
 525                        ret.append([ie[0], ie[1], prev, True])
 526                        stop = True
 527                    elif (stopOnTurnaround and ie[0]._incoming[ci][0].getDirection() == Connection.LINKDIR_TURN and
 528                          not stop):
 529                        ret.append([ie[0], ie[1], prev, True])
 530                        stop = True
 531                    else:
 532                        prev.append(ie[0])
 533                        mn.append([ci, ie[0].getLength() + ie[1], prev])
 534            if not stop:
 535                toProc.extend(mn)
 536        return ret
 537
 538    def getEdgesByOrigID(self, origID):
 539        if self._origIdx is None:
 540            self._origIdx = defaultdict(set)
 541            for the_edge in self._edges:
 542                for the_lane in the_edge.getLanes():
 543                    for oID in the_lane.getParam("origId", "").split():
 544                        self._origIdx[oID].add(the_edge)
 545        return self._origIdx[origID]
 546
 547    def getGeometries(self, useLanes, includeJunctions=False):
 548        for e in self._edges:
 549            if useLanes:
 550                for the_lane in e.getLanes():
 551                    yield the_lane.getID(), the_lane.getShape(), the_lane.getWidth()
 552            else:
 553                yield e.getID(), e.getShape(includeJunctions), sum([the_lane.getWidth() for the_lane in e.getLanes()])
 554
 555    def getBBoxXY(self):
 556        """
 557        Get the bounding box (bottom left and top right coordinates) for a net;
 558        Coordinates are in X and Y (not Lat and Lon)
 559
 560        :return [(bottom_left_X, bottom_left_Y), (top_right_X, top_right_Y)]
 561        """
 562        return [(self._ranges[0][0], self._ranges[1][0]),
 563                (self._ranges[0][1], self._ranges[1][1])]
 564
 565    # the diagonal of the bounding box of all nodes
 566    def getBBoxDiameter(self):
 567        return math.sqrt(
 568            (self._ranges[0][0] - self._ranges[0][1]) ** 2 +
 569            (self._ranges[1][0] - self._ranges[1][1]) ** 2)
 570
 571    def hasGeoProj(self):
 572        projString = self._location["projParameter"]
 573        return projString != "!"
 574
 575    def getGeoProj(self):
 576        if not self.hasGeoProj() or not HAVE_PYPROJ:
 577            raise RuntimeError("Network does not provide geo-projection or pyproj not installed.")
 578        if self._proj is None:
 579            try:
 580                self._proj = pyproj.Proj(projparams=self._location["projParameter"])
 581            except RuntimeError:
 582                if hasattr(pyproj.datadir, 'set_data_dir'):
 583                    pyproj.datadir.set_data_dir('/usr/share/proj')
 584                    self._proj = pyproj.Proj(projparams=self._location["projParameter"])
 585                raise
 586        return self._proj
 587
 588    def getLocationOffset(self):
 589        """ offset to be added after converting from geo-coordinates to UTM"""
 590        return list(map(float, self._location["netOffset"].split(",")))
 591
 592    def getBoundary(self):
 593        """ return xmin,ymin,xmax,ymax network coordinates"""
 594        return list(map(float, self._location["convBoundary"].split(",")))
 595
 596    def convertLonLat2XY(self, lon, lat, rawUTM=False):
 597        x, y = self.getGeoProj()(lon, lat)
 598        if rawUTM:
 599            return x, y
 600        else:
 601            x_off, y_off = self.getLocationOffset()
 602            return x + x_off, y + y_off
 603
 604    def convertXY2LonLat(self, x, y, rawUTM=False):
 605        if not rawUTM:
 606            x_off, y_off = self.getLocationOffset()
 607            x -= x_off
 608            y -= y_off
 609        return self.getGeoProj()(x, y, inverse=True)
 610
 611    def move(self, dx, dy, dz=0):
 612        for n in self._nodes:
 613            n._coord = (n._coord[0] + dx, n._coord[1] + dy, n._coord[2] + dz)
 614        for e in self._edges:
 615            for _lane in e.getLanes():
 616                _lane.setShape([(p[0] + dx, p[1] + dy, p[2] + dz) for p in _lane.getShape3D()])
 617            e.rebuildShape()
 618
 619    def getInternalPath(self, conn, fastest=False):
 620        minInternalCost = PRACTICAL_INFINITY
 621        minPath = None
 622        for c in conn:
 623            if c.getViaLaneID() != "":
 624                viaCost = 0
 625                viaID = c.getViaLaneID()
 626                viaPath = []
 627                while viaID != "":
 628                    viaLane = self.getLane(viaID)
 629                    viaCost += viaLane.getLength() if not fastest else viaLane.getLength() / viaLane.getSpeed()
 630                    viaID = viaLane.getOutgoing()[0].getViaLaneID()
 631                    viaPath.append(viaLane.getEdge())
 632                if viaCost < minInternalCost:
 633                    minInternalCost = viaCost
 634                    minPath = viaPath
 635        return minPath, minInternalCost
 636
 637    # @benchmark_cumulative
 638    # @profile
 639    def getOptimalPath(self, fromEdge, toEdge, fastest=False, maxCost=PRACTICAL_INFINITY, vClass=None,
 640                       reversalPenalty=0, includeFromToCost=True, withInternal=False, ignoreDirection=False,
 641                       fromPos=None, toPos=None, preferences={}, length=None):
 642        """
 643        Finds the optimal (shortest or fastest) path for vClass from fromEdge to toEdge
 644        by using using Dijkstra's algorithm.
 645        It returns a pair of a tuple of edges and the cost.
 646        If no path is found the first element is None.
 647        The cost for the returned path is equal to the sum of all edge costs in the path,
 648        including the internal connectors, if they are present in the network.
 649        The path itself does not include internal edges except for the case
 650        when the start or end edge are internal edges.
 651        The search may be limited using the given threshold.
 652        The preferences declare a mapping from the 'routingType' of each edge to divisor
 653        that is applied to the computed cost of that edge (i.e. a preference of 2 reduces cost by a factor of 0.5).
 654        """
 655
 656        if preferences:
 657            if fastest:
 658                def speedFunc(edge):
 659                    return preferences.get(edge.getRoutingType(), 1.0) * edge.getSpeed()
 660            else:
 661                def speedFunc(edge):
 662                    return preferences.get(edge.getRoutingType(), 1.0)
 663        elif fastest:
 664            def speedFunc(edge):
 665                return edge.getSpeed()
 666        else:
 667            def speedFunc(edge):
 668                return 1.0
 669
 670        def remainder(edge, pos):
 671            if pos < 0:
 672                return min(-pos, edge.getLength())
 673            return max(0., edge.getLength() - pos)
 674
 675        def getToNormalIncoming(edge):
 676            if edge.getFunction() == '':
 677                return [(e, None) for e in edge.getToNode().getIncoming() if e.getFunction() == '']
 678            else:
 679                return []
 680
 681        if self._edgeSuccessorCache != (vClass, ignoreDirection):
 682            self._edgeSuccessorCache = (vClass, ignoreDirection)
 683            for e1 in self.getEdges():
 684                e1._succCacche = tuple(chain(e1.getAllowedOutgoing(vClass).items(),
 685                                       e1.getIncoming().items() if ignoreDirection else [],
 686                                       getToNormalIncoming(e1) if ignoreDirection and not self.hasWalkingArea else []))
 687
 688        if self._edgeCostCache != (fastest, preferences):
 689            self._edgeCostCache = (fastest, preferences)
 690            for e1 in self.getEdges():
 691                e1._costCache = e1.getLength() / speedFunc(e1)
 692
 693        if self.hasInternal:
 694            appendix = []
 695            appendixCost = 0.
 696            while toEdge.getFunction() == "internal":
 697                appendix = [toEdge] + appendix
 698                appendixCost += toEdge._costCache
 699                toEdge = list(toEdge.getIncoming().keys())[0]
 700
 701        def finalizeCost(cost, path):
 702            if includeFromToCost:
 703                # add costs for (part of) the first edge, still needs to be fixed for wrong direction travel
 704                remainFrom = fromEdge.getLength() if fromPos is None else remainder(fromEdge, fromPos)
 705                cost += remainFrom / speedFunc(fromEdge)
 706                # remove costs for (part of) the last edge, still needs to be fixed for wrong direction travel
 707                removeTo = 0. if toPos is None else remainder(toEdge, toPos)
 708            else:
 709                removeTo = toEdge.getLength() if len(path) > 1 else 0.
 710            cost -= removeTo / speedFunc(toEdge)
 711            return cost
 712
 713        def constructPath(dist):
 714            # destination was already reached in a previous query
 715            cost, pred = dist[toEdge]
 716            if ((cost == PRACTICAL_INFINITY
 717                 # the final node may exceed max cost but the prior node may not
 718                 or (cost > maxCost and cost - toEdge._costCache > maxCost))):
 719                return None, cost
 720            path = [toEdge]
 721            while pred is not None:
 722                if self.hasInternal and withInternal:
 723                    viaPath, minInternalCost = self.getInternalPath(pred.getAllowedOutgoing(vClass).get(path[-1], []),
 724                                                                    fastest=fastest)
 725                    if viaPath is not None:
 726                        path += reversed(viaPath)
 727                path.append(pred)
 728                _, pred = dist[pred]
 729
 730            path.reverse()
 731            cost = finalizeCost(cost, path)
 732            assert cost >= 0
 733            if self.hasInternal:
 734                if appendix:
 735                    return tuple(path + appendix), cost + appendixCost
 736                elif ignoreDirection and self.hasWalkingArea and not withInternal:
 737                    return [e for e in path if e.getFunction() == ''], cost
 738            return tuple(path), cost
 739
 740        needLoop = (fromEdge == toEdge
 741                    and fromPos is not None
 742                    and toPos is not None
 743                    and fromPos > toPos
 744                    and not ignoreDirection)
 745
 746        seen = set()
 747        dist = {}
 748        q = []
 749        if self._routingCache is not None:
 750            if needLoop:
 751                # use cached results from all follower edges:
 752                bestCost = maxCost
 753                bestPath = None
 754                for e2, conn in fromEdge.getAllowedOutgoing(vClass).items():
 755                    path, cost = self.getOptimalPath(e2, toEdge, fastest=fastest, maxCost=maxCost, vClass=vClass,
 756                                                     reversalPenalty=reversalPenalty,
 757                                                     includeFromToCost=includeFromToCost,
 758                                                     withInternal=withInternal, fromPos=0, toPos=toPos,
 759                                                     preferences=preferences)
 760                    if path is not None and cost < bestCost:
 761                        bestPath = path
 762                        bestCost = cost
 763                if bestPath is not None:
 764                    path = [fromEdge]
 765                    if self.hasInternal and withInternal:
 766                        viaPath, minInternalCost = self.getInternalPath(
 767                            fromEdge.getAllowedOutgoing(vClass).get(path[0], []), fastest=fastest)
 768                        if viaPath is not None:
 769                            path += viaPath
 770                            bestCost += minInternalCost
 771                    path += list(bestPath)
 772                    if includeFromToCost:
 773                        bestCost += remainder(fromEdge, fromPos) / speedFunc(fromEdge)
 774                    return tuple(path), bestCost
 775                else:
 776                    return None, PRACTICAL_INFINITY
 777
 778            if self._routingCacheOD is not None and (fromEdge, toEdge, fastest, vClass) in self._routingCacheOD:
 779                cost, path = self._routingCacheOD[(fromEdge, toEdge, fastest, vClass)]
 780                if cost == PRACTICAL_INFINITY:
 781                    return None, cost
 782                cost = finalizeCost(cost, path)
 783                if cost > maxCost:
 784                    return None, cost
 785                else:
 786                    return tuple(path), cost
 787
 788            dist = self._routingCache(fromEdge, fastest, vClass, ignoreDirection, reversalPenalty,
 789                                      tuple(preferences.items()))
 790            if toEdge in dist:
 791                return constructPath(dist)
 792            else:
 793                # initialize heap from previous query
 794                q = []
 795                frontier = set(dist.keys())
 796                for cost, prev in dist.values():
 797                    frontier.discard(prev)
 798                for e in frontier:
 799                    cost, prev = dist[e]
 800                    heapq.heappush(q, (cost, e, prev))
 801        elif needLoop:
 802            # start search on successors of fromEdge
 803            for e2, conn in fromEdge.getAllowedOutgoing(vClass).items():
 804                q.append((e2._costCache, e2, fromEdge))
 805
 806        if len(dist) == 0:
 807            dist[fromEdge] = (0., None)
 808            if not needLoop:
 809                q.append((0., fromEdge, None))
 810
 811        while q:
 812            cost, e1, prev = heapq.heappop(q)
 813            if e1 == toEdge:
 814                return constructPath(dist)
 815            if cost > maxCost:
 816                return None, cost
 817            seen.add(e1)
 818            bidi = e1._bidi  # attribute access is faster than method access
 819            for e2, conn in e1._succCacche:
 820                if e2 not in seen:
 821                    newCost = cost + e2._costCache
 822                    #  print(cost, newCost, e2.getID(), speedFunc(e2))
 823                    if e2 == bidi:
 824                        newCost += reversalPenalty
 825                    if self.hasInternal and conn is not None:
 826                        viaPath, minInternalCost = self.getInternalPath(conn, fastest=fastest)
 827                        if viaPath is not None:
 828                            newCost += minInternalCost
 829                    if e2 not in dist or newCost < dist[e2][0]:
 830                        dist[e2] = (newCost, e1)
 831                        heapq.heappush(q, (newCost, e2, e1))
 832        return None, PRACTICAL_INFINITY
 833
 834    def getShortestPath(self, fromEdge, toEdge, maxCost=PRACTICAL_INFINITY, vClass=None, reversalPenalty=0,
 835                        includeFromToCost=True, withInternal=False, ignoreDirection=False,
 836                        fromPos=None, toPos=None, preferences={}):
 837        """
 838        Finds the shortest path from fromEdge to toEdge respecting vClass, using Dijkstra's algorithm.
 839        It returns a pair of a tuple of edges and the cost. If no path is found the first element is None.
 840        The cost for the returned path is equal to the sum of all edge lengths in the path,
 841        including the internal connectors, if they are present in the network.
 842        The path itself does not include internal edges except for the case
 843        when the start or end edge are internal edges.
 844        The search may be limited using the given threshold.
 845        The preferences declare a mapping from the 'routingType' of each edge to divisor
 846        that is applied to the lenght of that edge
 847        (i.e. a preference of 2 reduces reduces effective length by a factor of 0.5).
 848        """
 849
 850        return self.getOptimalPath(fromEdge, toEdge, False, maxCost, vClass, reversalPenalty,
 851                                   includeFromToCost, withInternal, ignoreDirection, fromPos, toPos,
 852                                   preferences)
 853
 854    def getFastestPath(self, fromEdge, toEdge, maxCost=PRACTICAL_INFINITY, vClass=None, reversalPenalty=0,
 855                       includeFromToCost=True, withInternal=False, ignoreDirection=False,
 856                       fromPos=None, toPos=None, preferences={}):
 857        """
 858        Finds the fastest path from fromEdge to toEdge respecting vClass, using Dijkstra's algorithm.
 859        It returns a pair of a tuple of edges and the cost. If no path is found the first element is None.
 860        The cost for the returned path is equal to the sum of all edge costs in the path,
 861        including the internal connectors, if they are present in the network.
 862        The path itself does not include internal edges except for the case
 863        when the start or end edge are internal edges.
 864        The search may be limited using the given threshold.
 865        The preferences declare a mapping from the 'routingType' of each edge to divisor
 866        that is applied to the computed traveltime of that edge
 867        (i.e. a preference of 2 reduces effective traveltime by a factor of 0.5).
 868        """
 869
 870        return self.getOptimalPath(fromEdge, toEdge, True, maxCost, vClass, reversalPenalty,
 871                                   includeFromToCost, withInternal, ignoreDirection, fromPos, toPos,
 872                                   preferences)
 873
 874    def getReachable(self, source, vclass=None, useIncoming=False, cache=None):
 875        if vclass is not None and not source.allows(vclass):
 876            raise RuntimeError("'{}' does not allow {}".format(source.getID(), vclass))
 877        fringe = [source]
 878        found = set()
 879        found.add(source)
 880        while len(fringe) > 0:
 881            new_fringe = []
 882            for e in fringe:
 883                if vclass == "pedestrian":
 884                    cands = chain(chain(*e.getIncoming().values()), chain(*e.getOutgoing().values()))
 885                else:
 886                    cands = chain(*(e.getIncoming().values() if useIncoming else e.getOutgoing().values()))
 887                # print("\n".join(map(str, list(cands))))
 888                for conn in cands:
 889                    if vclass is None or (
 890                            conn.getFromLane().allows(vclass)
 891                            and conn.getToLane().allows(vclass)):
 892                        for reachable in [conn.getTo(), conn.getFrom()]:
 893                            if reachable not in found:
 894                                # print("added %s via %s" % (reachable, conn))
 895                                if cache and reachable in cache:
 896                                    found.update(cache[reachable])
 897                                else:
 898                                    found.add(reachable)
 899                                    new_fringe.append(reachable)
 900            fringe = new_fringe
 901        if cache is not None:
 902            cache[source] = tuple(found)
 903        return found
 904
 905
 906class NetReader(handler.ContentHandler):
 907
 908    """Reads a network, storing the edge geometries, lane numbers and max. speeds"""
 909
 910    def __init__(self, **others):
 911        self._net = others.get('net', Net())
 912        self._currentEdge = None
 913        self._currentNode = None
 914        self._currentConnection = None
 915        self._currentLane = None
 916        self._crossingID2edgeIDs = {}
 917        self._withPhases = others.get('withPrograms', False)
 918        self._latestProgram = others.get('withLatestPrograms', False)
 919        if self._latestProgram:
 920            self._withPhases = True
 921        self._withConnections = others.get('withConnections', True)
 922        self._withFoes = others.get('withFoes', True)
 923        self._withPedestrianConnections = others.get('withPedestrianConnections', False)
 924        self._withMacroConnectors = others.get('withMacroConnectors', False)
 925        self._withInternal = others.get('withInternal', self._withPedestrianConnections)
 926        if self._withPedestrianConnections and not self._withInternal:
 927            sys.stderr.write("Warning: Option withPedestrianConnections requires withInternal\n")
 928            self._withInternal = True
 929        self._bidiEdgeIDs = {}
 930
 931    def startElement(self, name, attrs):
 932        if name == 'net':
 933            parts = attrs["version"].split('.', 1)
 934            self._net._version = (int(parts[0]), float(parts[1]))
 935        elif name == 'location':
 936            self._net.setLocation(attrs["netOffset"], attrs["convBoundary"], attrs[
 937                                  "origBoundary"], attrs["projParameter"])
 938        elif name == 'type':
 939            self._net._edgeTypes[attrs['id']] = EdgeType(attrs['id'], attrs.get('allow'), attrs.get('disallow'))
 940        elif name == 'edge':
 941            function = attrs.get('function', '')
 942            if (function == ''
 943                    or (self._withInternal and function in ['internal', 'crossing', 'walkingarea'])
 944                    or (self._withMacroConnectors and function == 'connector')):
 945                prio = -1
 946                if 'priority' in attrs:
 947                    prio = int(attrs['priority'])
 948
 949                # get the  ids
 950                edgeID = attrs['id']
 951                fromNodeID = attrs.get('from', None)
 952                toNodeID = attrs.get('to', None)
 953
 954                # for internal junctions use the junction's id for from and to node
 955                if function == 'internal' or function == 'crossing' or function == 'walkingarea':
 956                    fromNodeID = toNodeID = edgeID[1:edgeID.rfind('_')]
 957
 958                # remember edges crossed by pedestrians to link them later to the crossing objects
 959                if function == 'crossing':
 960                    self._crossingID2edgeIDs[edgeID] = attrs.get('crossingEdges').split(' ')
 961
 962                self._currentEdge = self._net.addEdge(edgeID, fromNodeID, toNodeID, prio, function,
 963                                                      attrs.get('name', ''), attrs.get('type', ''),
 964                                                      attrs.get('routingType', ''))
 965
 966                self._currentEdge.setRawShape(convertShape(attrs.get('shape', '')))
 967
 968                bidi = attrs.get('bidi', '')
 969                if bidi:
 970                    self._bidiEdgeIDs[edgeID] = bidi
 971            else:
 972                if function in ['crossing', 'walkingarea']:
 973                    self._net._crossings_and_walkingAreas.add(attrs['id'])
 974                elif function == 'connector':
 975                    self._net._macroConnectors.add(attrs['id'])
 976                self._currentEdge = None
 977        elif name == 'lane' and self._currentEdge is not None:
 978            self._currentLane = self._net.addLane(
 979                self._currentEdge,
 980                float(attrs['speed']),
 981                float(attrs['length']),
 982                float(attrs.get('width', 3.2)),
 983                attrs.get('allow'),
 984                attrs.get('disallow'),
 985                attrs.get('acceleration') == "1")
 986            self._currentLane.setShape(convertShape(attrs.get('shape', '')))
 987        elif name == 'neigh' and self._currentLane is not None:
 988            self._currentLane.setNeigh(attrs['lane'])
 989        elif name == 'junction':
 990            if attrs['id'][0] != ':':
 991                intLanes = None
 992                if self._withInternal:
 993                    intLanes = attrs["intLanes"].split(" ")
 994                self._currentNode = self._net.addNode(attrs['id'], attrs['type'],
 995                                                      tuple(
 996                                                          map(float, [attrs['x'], attrs['y'],
 997                                                                      attrs['z'] if 'z' in attrs else '0'])),
 998                                                      attrs['incLanes'].split(" "), intLanes)
 999                self._currentNode.setShape(
1000                    convertShape(attrs.get('shape', '')))
1001                if 'fringe' in attrs:
1002                    self._currentNode._fringe = attrs['fringe']
1003
1004        elif name == 'succ' and self._withConnections:  # deprecated
1005            if attrs['edge'][0] != ':':
1006                self._currentEdge = self._net.getEdge(attrs['edge'])
1007                self._currentLane = attrs['lane']
1008                self._currentLane = int(
1009                    self._currentLane[self._currentLane.rfind('_') + 1:])
1010            else:
1011                self._currentEdge = None
1012        elif name == 'succlane' and self._withConnections:  # deprecated
1013            lid = attrs['lane']
1014            if lid[0] != ':' and lid != "SUMO_NO_DESTINATION" and self._currentEdge:
1015                connected = self._net.getEdge(lid[:lid.rfind('_')])
1016                tolane = int(lid[lid.rfind('_') + 1:])
1017                if 'tl' in attrs and attrs['tl'] != "":
1018                    tl = attrs['tl']
1019                    tllink = int(attrs['linkIdx'])
1020                    tlid = attrs['tl']
1021                    toEdge = self._net.getEdge(lid[:lid.rfind('_')])
1022                    tolane2 = toEdge._lanes[tolane]
1023                    tls = self._net.addTLS(
1024                        tlid, self._currentEdge._lanes[self._currentLane], tolane2, tllink)
1025                    self._currentEdge.setTLS(tls)
1026                else:
1027                    tl = ""
1028                    tllink = -1
1029                toEdge = self._net.getEdge(lid[:lid.rfind('_')])
1030                tolane = toEdge._lanes[tolane]
1031                viaLaneID = attrs['via']
1032                self._net.addConnection(self._currentEdge, connected, self._currentEdge._lanes[
1033                                        self._currentLane], tolane,
1034                                        attrs['dir'], tl, tllink, -1,
1035                                        attrs.get('allow'), attrs.get('disallow'), attrs['state'], viaLaneID)
1036        elif name == 'connection' and self._withConnections and (attrs['from'][0] != ":" or self._withInternal):
1037            fromEdgeID = attrs['from']
1038            toEdgeID = attrs['to']
1039            if ((self._withPedestrianConnections or not (fromEdgeID in self._net._crossings_and_walkingAreas or
1040                                                         toEdgeID in self._net._crossings_and_walkingAreas))
1041                and (self._withMacroConnectors or not (fromEdgeID in self._net._macroConnectors or toEdgeID in
1042                                                       self._net._macroConnectors))):
1043                fromEdge = self._net.getEdge(fromEdgeID)
1044                toEdge = self._net.getEdge(toEdgeID)
1045                fromLane = fromEdge.getLane(int(attrs['fromLane']))
1046                toLane = toEdge.getLane(int(attrs['toLane']))
1047                if 'tl' in attrs and attrs['tl'] != "":
1048                    tl = attrs['tl']
1049                    tllink = int(attrs['linkIndex'])
1050                    tllink2 = int(attrs.get('linkIndex2', -1))
1051                    tls = self._net.addTLS(tl, fromLane, toLane, tllink)
1052                    fromEdge.setTLS(tls)
1053                else:
1054                    tl = ""
1055                    tllink = -1
1056                    tllink2 = -1
1057                try:
1058                    viaLaneID = attrs['via']
1059                except KeyError:
1060                    viaLaneID = ''
1061
1062                self._currentConnection = self._net.addConnection(
1063                    fromEdge, toEdge, fromLane, toLane, attrs['dir'], tl,
1064                    tllink, tllink2, attrs.get('allow'), attrs.get('disallow'), attrs['state'], viaLaneID)
1065
1066        # 'row-logic' is deprecated!!!
1067        elif self._withFoes and name == 'ROWLogic':
1068            self._currentNode = attrs['id']
1069        elif name == 'logicitem' and self._withFoes:  # deprecated
1070            self._net.setFoes(
1071                self._currentNode, int(attrs['request']), attrs["foes"], attrs["response"])
1072        elif name == 'request' and self._withFoes:
1073            self._currentNode.setFoes(
1074                int(attrs['index']), attrs["foes"], attrs["response"])
1075        # tl-logic is deprecated!!! NOTE: nevertheless, this is still used by
1076        # netconvert... (Leo)
1077        elif self._withPhases and name == 'tlLogic':
1078            self._currentProgram = self._net.addTLSProgram(
1079                attrs['id'], attrs['programID'],
1080                intIfPossible(float(attrs['offset'])), attrs['type'], self._latestProgram)
1081        elif self._withPhases and name == 'phase':
1082            self._currentProgram.addPhase(
1083                attrs['state'],
1084                intIfPossible(float(attrs['duration'])),
1085                intIfPossible(float(attrs['minDur'])) if 'minDur' in attrs else -1,
1086                intIfPossible(float(attrs['maxDur'])) if 'maxDur' in attrs else -1,
1087                list(map(int, attrs['next'].split())) if 'next' in attrs else [],
1088                attrs['name'] if 'name' in attrs else ""
1089            )
1090        elif name == 'roundabout':
1091            self._net.addRoundabout(
1092                attrs['nodes'].split(), attrs['edges'].split())
1093        elif name == 'param':
1094            if self._currentLane is not None:
1095                self._currentLane.setParam(attrs['key'], attrs['value'])
1096            elif self._currentEdge is not None:
1097                self._currentEdge.setParam(attrs['key'], attrs['value'])
1098            elif self._currentNode is not None:
1099                self._currentNode.setParam(attrs['key'], attrs['value'])
1100            elif self._currentConnection is not None:
1101                self._currentConnection.setParam(attrs['key'], attrs['value'])
1102            elif self._withPhases and self._currentProgram is not None:
1103                self._currentProgram.setParam(attrs['key'], attrs['value'])
1104
1105    def endElement(self, name):
1106        if name == 'lane':
1107            self._currentLane = None
1108        elif name == 'edge':
1109            self._currentEdge = None
1110        elif name == 'junction':
1111            self._currentNode = None
1112        elif name == 'connection':
1113            self._currentConnection = None
1114        # 'row-logic' is deprecated!!!
1115        elif name == 'ROWLogic' or name == 'row-logic':
1116            self._haveROWLogic = False
1117        # tl-logic is deprecated!!!
1118        elif self._withPhases and (name == 'tlLogic' or name == 'tl-logic'):
1119            self._currentProgram = None
1120        elif name == 'net':
1121            for edgeID, bidiID in self._bidiEdgeIDs.items():
1122                self._net.getEdge(edgeID)._bidi = self._net.getEdge(bidiID)
1123
1124    def endDocument(self):
1125        # set crossed edges of pedestrian crossings
1126        for crossingID, crossedEdgeIDs in self._crossingID2edgeIDs.items():
1127            pedCrossing = self._net.getEdge(crossingID)
1128            for crossedEdgeID in crossedEdgeIDs:
1129                pedCrossing._addCrossingEdge(self._net.getEdge(crossedEdgeID))
1130
1131    def getNet(self):
1132        return self._net
1133
1134
1135def convertShape(shapeString):
1136    """ Convert xml shape string into float tuples.
1137
1138    This method converts the 2d or 3d shape string from SUMO's xml file
1139    into a list containing 3d float-tuples. Non existent z coordinates default
1140    to zero. If shapeString is empty, an empty list will be returned.
1141    """
1142
1143    cshape = []
1144    for pointString in shapeString.split():
1145        p = [float(e) for e in pointString.split(",")]
1146        if len(p) == 2:
1147            cshape.append((p[0], p[1], 0.))
1148        elif len(p) == 3:
1149            cshape.append(tuple(p))
1150        else:
1151            raise ValueError(
1152                'Invalid shape point "%s", should be either 2d or 3d' % pointString)
1153    return cshape
1154
1155
1156def lane2edge(laneID):
1157    return laneID[:laneID.rfind("_")]
1158
1159
1160def lane2index(laneID):
1161    return int(laneID[laneID.rfind("_") + 1:])
1162
1163
1164def hasInternal(filename):
1165    with openz(filename) as f:
1166        for line in f:
1167            if '<edge id="' in line:
1168                if '<edge id=":' in line:
1169                    return True
1170                else:
1171                    return False
1172    return False
1173
1174
1175def readNet(filename, **others):
1176    """ load a .net.xml file
1177    The following named options are supported:
1178
1179        'net' : initialize data structures with an existing net object (default Net())
1180        'withPrograms' : import all traffic light programs (default False)
1181        'withLatestPrograms' : import only the last program for each traffic light.
1182                               This is the program that would be active in sumo by default.
1183                               (default False)
1184        'withConnections' : import all connections (default True)
1185        'withFoes' : import right-of-way information (default True)
1186        'withInternal' : import internal edges and lanes (default False)
1187        'withPedestrianConnections' : import connections between sidewalks, crossings (default False)
1188        'lxml' : set to False to use the xml.sax parser instead of the lxml parser
1189        'maxcache' : set maximum cache size (default 1000) or 0 to disable optimal route caching
1190    """
1191    netreader = NetReader(**others)
1192    try:
1193        source = gzip.open(filename)
1194        source.read(10)
1195        source.seek(0)
1196    except IOError:
1197        source = filename
1198    if HAVE_LXML and others.get("lxml", True):
1199        if isinstance(source, pathlib.Path):
1200            source = str(source)
1201        for event, v in lxml.etree.iterparse(source, events=("start", "end")):
1202            if event == "start":
1203                netreader.startElement(v.tag, v.attrib)
1204            elif event == "end":
1205                netreader.endElement(v.tag)
1206            v.clear()  # reduce memory footprint
1207    else:
1208        parse(source, netreader)
1209    net = netreader.getNet()
1210    maxcache = others.get('maxcache', 1000)
1211    if HAVE_LRU_CACHE and maxcache is not None and maxcache > 0:
1212        net.initRoutingCache(maxcache)
1213    return net