コード例 #1
0
ファイル: roadNetwork.py プロジェクト: michalis/pyDTATools
    def __init__(self, name, simStartTimeInMin,
                 simEndTimeInMin, simTimeStepInMin):

        self.simStartTimeInMin = simStartTimeInMin
        self.simEndTimeInMin = simEndTimeInMin
        self.simTimeStepInMin = simTimeStepInMin
        
        self.name = name 
        self._vertices = OrderedDict()
        self._edges = OrderedDict()
        self._maxVertexId = 0
コード例 #2
0
ファイル: roadNetwork.py プロジェクト: michalis/pyDTATools
class Graph(object):

    def __init__(self, name, simStartTimeInMin,
                 simEndTimeInMin, simTimeStepInMin):

        self.simStartTimeInMin = simStartTimeInMin
        self.simEndTimeInMin = simEndTimeInMin
        self.simTimeStepInMin = simTimeStepInMin
        
        self.name = name 
        self._vertices = OrderedDict()
        self._edges = OrderedDict()
        self._maxVertexId = 0
        
    def addVertex(self, newVertex):

        if newVertex.id in self._vertices:
            raise GraphError("Vertex %s already in the network" % newVertex.id)
        self._vertices[newVertex.id] = newVertex
        if int(newVertex.id) > self._maxVertexId:
            self._maxVertexId = int(newVertex.id) 
        
    def addEdge(self, newEdge):
        
        startVertex = self.getVertex(newEdge.startVertexId)
        endVertex = self.getVertex(newEdge.endVertexId)

        if self.hasEdge(startVertex.id, endVertex.id):
            raise GraphError("Edge %s already exists" % newEdge.iid_)

        startVertex.addOutEdge(newEdge)
        endVertex.addInEdge(newEdge)

        newEdge.simStartTimeInMin = self.simStartTimeInMin
        newEdge.simEndTimeInMin = self.simEndTimeInMin
        newEdge.simTimeStepInMin = self.simTimeStepInMin

        self._edges[startVertex.id, endVertex.id] = newEdge

    def deleteEdge(self, edgeToDelete):
        
        movsToDelete1 = [mov for mov in edgeToDelete.iterOutMovements()] 
        movsToDelete2 = [mov for mov in edgeToDelete.iterInMovements()]

        for movToDelete in movsToDelete1:
            edgeToDelete.deleteOutMovement(movToDelete) 
        
        for movToDelete in movsToDelete2:
            movToDelete.inEdge.deleteOutMovement(movToDelete) 

        edgeToDelete.startVertex._deleteOutEdge(edgeToDelete)
        edgeToDelete.endVertex._deleteInEdge(edgeToDelete)

        del self._edges[edgeToDelete.startVertexId, edgeToDelete.endVertexId]

    def deleteVertex(self, vertexToDelete):

        edgesToDelete = [edge for edge in chain(vertexToDelete.iterInEdges(),
                                                vertexToDelete.iterOutEdges())]

        for edge in edgesToDelete:
            self.deleteEdge(edge) 

        del self._vertices[vertexToDelete.id] 
                             
    def iterVertices(self):
        
        return self._vertices.itervalues()

    def iterEdges(self):
        
        return self._edges.itervalues()

    def hasVertex(self, vertexId):
        
        return vertexId in self._vertices

    def hasEdge(self, startVertexId, endVertexId):
        
        return (startVertexId, endVertexId) in self._edges

    def getVertex(self, vertexId):

        try:
            return self._vertices[vertexId]
        except KeyError, e:
            raise GraphError("Vertex %s not in the graph" % vertexId)