sumolib.net.generator.network

  1# Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
  2# Copyright (C) 2013-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    network.py
 14# @author  Daniel Krajzewicz
 15# @date    2013-10-10
 16
 17from __future__ import absolute_import
 18from __future__ import print_function
 19import os
 20import sys
 21import subprocess
 22import tempfile
 23
 24if 'SUMO_HOME' in os.environ:
 25    tools = os.path.join(os.environ['SUMO_HOME'], 'tools')
 26    sys.path.append(os.path.join(tools))
 27import sumolib  # noqa
 28
 29
 30class Node:
 31
 32    def __init__(self, nid, x, y, nodeType):
 33        self.nid = nid
 34        self.x = x
 35        self.y = y
 36        self.nodeType = nodeType
 37        self.crossings = []
 38
 39    def getNetworkCoordinates(self):
 40        t = self.nid.split("/")
 41        return [int(t[0]), int(t[1])]
 42
 43    def addCrossing(self, fromEdge, toEdge):
 44        self.crossings.append([fromEdge, toEdge])
 45
 46
 47class Lane:
 48
 49    def __init__(self, dirs=None, allowed=None, disallowed=None):
 50        self.dirs = dirs
 51        self.allowed = allowed
 52        self.disallowed = disallowed
 53        if self.dirs is None:
 54            self.dirs = []
 55
 56
 57class Split:
 58
 59    def __init__(self, distance, lanes):
 60        self.distance = distance
 61        self.lanes = lanes
 62
 63
 64class Edge:
 65
 66    def __init__(self, eid=None, fromNode=None, toNode=None, numLanes=None, maxSpeed=None, lanes=None, splits=None):
 67        self.eid = eid
 68        self.fromNode = fromNode
 69        self.toNode = toNode
 70        self.numLanes = numLanes
 71        self.maxSpeed = maxSpeed
 72        self.lanes = lanes
 73        if self.lanes is None:
 74            self.lanes = [Lane() for _ in range(numLanes)]
 75        self.splits = splits
 76        if self.splits is None:
 77            self.splits = []
 78        if numLanes is None:
 79            numLanes = len(self.lanes)
 80
 81    def addSplit(self, distance, lanesToRight=None, lanesToLeft=None):
 82        if len(self.splits) == 0:
 83            if lanesToRight is None:
 84                lanesToRight = 0
 85            if lanesToLeft is None:
 86                lanesToLeft = 0
 87            lanes = range(lanesToRight, self.numLanes + lanesToRight)
 88            self.splits.append(Split(0, lanes))
 89            lanes = range(0, self.numLanes + lanesToRight + lanesToLeft)
 90            self.splits.append(Split(distance, lanes))
 91            self.lanes = [Lane() for _ in range(lanesToRight)] + self.lanes
 92            self.lanes += [Lane() for _ in range(lanesToLeft)]
 93
 94    def getConnections(self, net):
 95        ret = []
 96
 97        seen = {}
 98        for i, l in enumerate(self.lanes):
 99            for d in l.dirs:
100                if d not in seen:
101                    seen[d] = 0
102                c = net.dir2connection(d, self, i, seen[d])
103                if c is not None:
104                    ret.append(c)
105                seen[d] = seen[d] + 1
106        return ret
107
108    def getDirection(self):
109        n1c = self.fromNode.getNetworkCoordinates()
110        n2c = self.toNode.getNetworkCoordinates()
111        return [n2c[0] - n1c[0], n2c[1] - n1c[1]]
112
113
114class Connection:
115
116    def __init__(self, fromEdge, fromLane, toEdge, toLane):
117        self.fromEdge = fromEdge
118        self.fromLane = fromLane
119        self.toEdge = toEdge
120        self.toLane = toLane
121
122
123class E1:
124
125    def __init__(self, id, laneID, pos, freq, outputFile):
126        self.id = id
127        self.laneID = laneID
128        self.pos = pos
129        self.freq = freq
130        self.outputFile = outputFile
131
132
133class Net:
134
135    def __init__(self, defaultNode, defaultEdge):
136        self._nodes = {}
137        self._edges = {}
138        self._defaultEdge = defaultEdge
139        if self._defaultEdge is None:
140            self._defaultEdge = Edge(None, None, None, 2, 13.89)
141        self._defaultNode = defaultNode
142        if self._defaultNode is None:
143            self._defaultNode = Node(None, None, None, "traffic_light")
144        self._e1 = {}
145        self.netName = None
146
147    def addNode(self, n):
148        self._nodes[n.nid] = n
149
150    def getNode(self, id):
151        if id in self._nodes:
152            return self._nodes[id]
153        return None
154
155    def addEdge(self, e):
156        self._edges[e.eid] = e
157
158    def addE1Detectors(self, id, laneID, pos, freq, outputFile):
159        e1 = E1(id, laneID, pos, freq, outputFile)
160        self._e1[e1.id] = e1
161        return e1
162
163    def getEdge(self, id):
164        if id in self._edges:
165            return self._edges[id]
166        return None
167
168    def getDefaultEdge(self, n1, n2):
169        return self._defaultEdge
170
171    def buildEdge(self, n1, n2):
172        defEdge = self.getDefaultEdge(n1, n2)
173        splits = []
174        for s in defEdge.splits:
175            splits.append(s)
176        lanes = list(defEdge.lanes)
177        numLanes = defEdge.numLanes
178        maxSpeed = defEdge.maxSpeed
179        e = Edge(n1.nid + "_to_" + n2.nid, n1, n2, numLanes=numLanes,
180                 maxSpeed=maxSpeed, lanes=lanes, splits=splits)
181        return e
182
183    def connectNodes(self, node1, node2, bidi, centralReservation):
184        n1 = self._nodes[node1]
185        n2 = self._nodes[node2]
186        self.addEdge(self.buildEdge(n1, n2))
187        if bidi:
188            self.addEdge(self.buildEdge(n2, n1))
189
190    def getDirectionFromNode(self, n, dir):
191        nc = n.getNetworkCoordinates()
192        eid = n.nid + "_to_" + str(nc[0] + dir[0]) + "/" + str(nc[1] + dir[1])
193        if eid in self._edges:
194            return self._edges[eid]
195        return None
196
197    def getMatchingOutgoing(self, edge, direction):
198        edir = edge.getDirection()
199        if direction == "s":
200            return self.getDirectionFromNode(edge.toNode, edir)
201        elif direction == "t":
202            return self.getDirectionFromNode(edge.toNode, [-1 * edir[0], -1 * edir[1]])
203        elif direction == "r":
204            # look, the following is because SUMO's coordinates don't match:
205            #  the y-direction starts at the bottom, while x on right
206            if edir[0] == 0:
207                return self.getDirectionFromNode(edge.toNode, [1 * edir[1], 1 * edir[0]])
208            else:
209                return self.getDirectionFromNode(edge.toNode, [-1 * edir[1], -1 * edir[0]])
210        elif direction == "l":
211            # the same as above
212            if edir[0] != 0:
213                return self.getDirectionFromNode(edge.toNode, [1 * edir[1], 1 * edir[0]])
214            else:
215                return self.getDirectionFromNode(edge.toNode, [-1 * edir[1], -1 * edir[0]])
216        else:
217            raise RuntimeError("Unrecognized direction '%s'" % direction)
218
219    def dir2connection(self, direction, edge, lane, seen):
220        toEdge = self.getMatchingOutgoing(edge, direction)
221        if toEdge is not None:
222            if toEdge.lanes[seen].allowed != edge.lanes[lane].allowed:
223                seen = seen + 1
224            return Connection(edge, lane, toEdge, seen)
225        return None
226
227    def build(self, netName="net.net.xml"):
228        connections = []
229        nodesFile = tempfile.NamedTemporaryFile(mode="w", delete=False)
230        print("<nodes>", file=nodesFile)
231        for nid in self._nodes:
232            n = self._nodes[nid]
233            print('    <node id="%s" x="%s" y="%s" type="%s"/>' % (
234                n.nid, n.x, n.y, n.nodeType), file=nodesFile)
235        print("</nodes>", file=nodesFile)
236        nodesFile.close()
237
238        edgesFile = tempfile.NamedTemporaryFile(mode="w", delete=False)
239        print("<edges>", file=edgesFile)
240        for eid in self._edges:
241            e = self._edges[eid]
242            print('    <edge id="%s" from="%s" to="%s" numLanes="%s" speed="%s">' % (
243                e.eid, e.fromNode.nid, e.toNode.nid, e.numLanes, e.maxSpeed), file=edgesFile)
244            for s in e.splits:
245                print('        <split pos="%s" lanes="%s"/>' %
246                      (-s.distance, " ".join(map(str, s.lanes))), file=edgesFile)
247
248            """
249        for i,l in enumerate(e.lanes):
250            if l.allowed==None and l.disallowed==None:
251                continue
252            ls =  '        <lane index="%s" ' % (i)
253            if l.allowed!=None:
254                ls = ls + 'allow="%s"' % l.allowed
255            if l.disallowed!=None:
256                ls = ls + 'disallow="%s"' % l.disallowed
257            print >> edgesFile, ls+'/>'
258        """
259
260            connections.extend(e.getConnections(self))
261            print('    </edge>', file=edgesFile)
262
263            hadConstraints = False
264            for i, l in enumerate(e.lanes):
265                if l.allowed is None and l.disallowed is None:
266                    continue
267                hadConstraints = True
268            if hadConstraints:
269                for s in e.splits:
270                    eid = e.eid
271                    if s.distance != 0:
272                        eid = eid + ".%s" % -s.distance
273                    print('    <edge id="%s">' % (eid), file=edgesFile)
274                    for i, l in enumerate(e.lanes):
275                        # if i not in s.lanes:
276                        #    continue
277                        if l.allowed is None and l.disallowed is None:
278                            continue
279                        ls = '        <lane index="%s" ' % (i)
280                        if l.allowed is not None:
281                            ls = ls + 'allow="%s"' % l.allowed
282                        if l.disallowed is not None:
283                            ls = ls + 'disallow="%s"' % l.disallowed
284                        print(ls + '/>', file=edgesFile)
285                    print('    </edge>', file=edgesFile)
286
287        print("</edges>", file=edgesFile)
288        edgesFile.close()
289
290        connectionsFile = tempfile.NamedTemporaryFile(mode="w", delete=False)
291        print("<connections>", file=connectionsFile)
292        for c in connections:
293            eid = c.fromEdge.eid
294            if len(c.fromEdge.splits) > 1:
295                eid = eid + ".-" + str(c.fromEdge.splits[-1].distance)
296            print('    <connection from="%s" to="%s" fromLane="%s" toLane="%s"/>' % (
297                eid, c.toEdge.eid, c.fromLane, c.toLane), file=connectionsFile)
298        for n in self._nodes:
299            if len(self._nodes[n].crossings) == 0:
300                continue
301            for c in self._nodes[n].crossings:
302                print('    <crossing node="%s" edges="%s"/>' % (
303                    n, " ".join(c)), file=connectionsFile)
304        print("</connections>", file=connectionsFile)
305        connectionsFile.close()
306
307        netconvert = sumolib.checkBinary("netconvert")
308
309        subprocess.call([netconvert, "-v", "-n", nodesFile.name, "-e", edgesFile.name, "-x", connectionsFile.name,
310                         "-o", netName])
311        os.remove(nodesFile.name)
312        os.remove(edgesFile.name)
313        os.remove(connectionsFile.name)
314        self.netName = netName
315        return netName
316
317    def buildDetectors(self, filename):
318        e1File = filename
319        fdo = open(e1File, "w")
320        print("<additional>", file=fdo)
321        for e1id in self._e1:
322            e1 = self._e1[e1id]
323            print('    <e1Detector id="%s" lane="%s" pos="%s" freq="%s" file="%s"/>' % (
324                e1.id, e1.laneID, e1.pos, e1.freq, e1.outputFile), file=fdo)
325        print("</additional>", file=fdo)
326        fdo.close()