def generateDictsFromShp(shapeFile,outputPath): 
    'Reads nodes and node weights from a point shapefile.'
    rootDir, fc = os.path.split(shapeFile)
    file, ext = os.path.splitext(fc)

    if not os.path.exists(outputPath):
        try:
            os.mkdir(outputPath)
        except:
            print "ERROR: could not create new directory", outputPath
    ds = ogr.Open(shapeFile)
    ptLayer = ds.GetLayer(0)
    
    nodesByClusterID=collections.defaultdict(list)
    clusterByNode={}
    nodes={}
    centers={}
    LVLenDict={}
    
    feat = ptLayer.GetNextFeature()
    while feat is not None:
        nodeWeight = 1
        geomRef = feat.GetGeometryRef()
        x = geomRef.GetX()
        y = geomRef.GetY()
        FID = feat.GetFID()
        nodes[FID] = network.Node(FID, x, y, nodeWeight) #Households
        centers[FID]=network.Node(FID, x, y, nodeWeight) #Transformers (center of mass of the cluster)
        
        clusterByNode[nodes[FID]]=FID 
        nodesByClusterID[FID].append(nodes[FID])
        LVLenDict[FID]=0
        feat = ptLayer.GetNextFeature()
    ds.Destroy()
    return nodesByClusterID,clusterByNode,nodes,centers,LVLenDict
def generateNodeDictFromShp(shapeFile, outputPath):
    'Reads nodes and node weights from a point shapefile.'
    rootDir, fc = os.path.split(shapeFile)
    file, ext = os.path.splitext(fc)

    if not os.path.exists(outputPath):
        try:
            os.mkdir(outputPath)
        except:
            print "ERROR: could not create new directory", outputPath
    ds = ogr.Open(shapeFile)
    ptLayer = ds.GetLayer(0)

    #nodesByClusterID=collections.defaultdict(list)
    #clustersByNodeID={}
    nodes = {}

    feat = ptLayer.GetNextFeature()
    while feat is not None:
        nodeWeight = 1
        geomRef = feat.GetGeometryRef()
        x = geomRef.GetX()
        y = geomRef.GetY()
        FID = feat.GetFID()
        nodes[FID] = network.Node(FID, x, y, nodeWeight)  #Households
        feat = ptLayer.GetNextFeature()
    ds.Destroy()
    return nodes
示例#3
0
def generateDictsFromShp(shapeFile, outputPath):
    'Reads nodes and node weights from a point shapefile.'
    rootDir, fc = os.path.split(shapeFile)
    file, ext = os.path.splitext(fc)

    if not os.path.exists(outputPath):
        try:
            os.mkdir(outputPath)
        except:
            print "ERROR: could not create new directory", outputPath
    ds = ogr.Open(shapeFile)
    ptLayer = ds.GetLayer(0)
    #clusters = {}
    nodesByClusterID = collections.defaultdict(list)
    clusterByNode = {}
    nodes = {}
    centers = {}
    LVCostDict = {}
    #nodesArray=[]
    feat = ptLayer.GetNextFeature()
    while feat is not None:
        nodeWeight = 1
        geomRef = feat.GetGeometryRef()
        x = geomRef.GetX()
        y = geomRef.GetY()
        FID = feat.GetFID()
        nodes[FID] = network.Node(FID, x, y, nodeWeight)  #tum nodelar
        centers[FID] = network.Node(
            FID, x, y, nodeWeight)  #tum centerlar node olarak tutulur
        #clusters[FID]=Cluster([nodes[FID]],FID,x,y,nodeWeight) #tum clusterlar

        #clusterByNode[nodes[FID]]=Cluster([nodes[FID]],FID,x,y,nodeWeight) # node'u ver clusteri dondur
        clusterByNode[
            nodes[FID]] = FID  #clusterin kendini degil sadece IDsini tutucak
        #nodesByClusterID[FID]=clusterByNode[nodes[FID]].getNodes() #clusterID ver clusterin nodelarini dondur
        nodesByClusterID[FID].append(nodes[FID])
        LVCostDict[FID] = 0
        #nodesArray.append((x,y))
        feat = ptLayer.GetNextFeature()
    ds.Destroy()
    return nodesByClusterID, clusterByNode, nodes, centers, LVCostDict
def generateRootNode(nodesByClusterID, ID, nodes):
    sumX = 0
    sumY = 0
    numNodes = 0
    for nodeID in nodesByClusterID[ID]:
        sumX = sumX + nodes[nodeID].getX()
        sumY = sumY + nodes[nodeID].getY()
        numNodes += 1

    centerX = sumX / numNodes
    centerY = sumY / numNodes
    newNode = network.Node(ID, centerX, centerY,
                           1)  # key can be changed! karismasin simdilik
    return newNode
def readNodesFromShp(shapefile):
    'Reads nodes and node weights from a point shapefile.'
    ds = ogr.Open(shapefile)
    ptLayer = ds.GetLayer(0)
    nodes = {}
    feat = ptLayer.GetNextFeature()
    while feat is not None:
        nodeWeight = 1
        geomRef = feat.GetGeometryRef()
        x = geomRef.GetX()
        y = geomRef.GetY()
        FID = feat.GetFID()
        nodes[FID] = network.Node(FID, x, y, nodeWeight)
        feat = ptLayer.GetNextFeature()
    ds.Destroy()

    return nodes
示例#6
0
def readNodesFromShp(shapefile):
    'Reads nodes and node weights from a point shapefile.'
    ds = ogr.Open(shapefile)
    ptLayer = ds.GetLayer(0)
    nodes = {}
    nodesArray=[]
    feat = ptLayer.GetNextFeature()
    while feat is not None:
        #try:
         #   weightField = feat.GetFieldIndex("Weight")
          #  nodeWeight = feat.GetField(weightField)
        #except:
        nodeWeight = 1
        geomRef = feat.GetGeometryRef()
        x = geomRef.GetX()
        y = geomRef.GetY()
        FID = feat.GetFID()
        nodes[FID] = network.Node(FID, x, y, nodeWeight)
        nodesArray.append((x,y))
        feat = ptLayer.GetNextFeature()
    ds.Destroy()
    return nodes, nodesArray
def main(argv=None):
    if argv is None:
        argv = sys.argv
    try:
        try:
            opts, args = getopt.getopt(argv[1:], "h", ["help"])
        except getopt.GetoptError, msg:
            raise Usage(msg)
        if len(args) == 0:
            raise Usage("No arguments specified.")

        inputShapefile = argv[1]
        distancesDir = argv[2]
        startPtShapefile = argv[3]
        maxNodes = float(argv[4])
        subnetIDFieldname = argv[5]
        orderFieldname = argv[6]

        distFile = distancesDir + os.sep + "dists.txt"
        nodeFile = distancesDir + os.sep + "nodes.txt"
        nodes = fileRW.readNodesFromTxt(nodeFile)
        segs = fileRW.readSegsFromTxt(distFile, nodes)
        
        gp.addMessage("Reading starting point...")
        rows = gp.searchCursor(startPtShapefile)
        desc = gp.describe(startPtShapefile)
        row = rows.next()
        feat = row.GetValue(desc.ShapeFieldName)
        FID = row.getValue("FID")
        point = feat.getPart(0)
        startNode = network.Node(FID, point.x, point.y, None)
        del rows

        nodeDict = buildAssocDict(segs)

        gp.addMessage("Calculating subnets...")
        nodeOrder = {}
        subNet = {}
        distList = makeDistList(startNode, nodes)
        n = 0
        while len(segs) > 0:
            print n
            # Choose first node
            firstNodeID = distList[0].getNode()
            tree = primsAlg(segs, maxNodes, firstNodeID, nodeDict)
            m = 0
            for node in tree.getNodes():
                nodeID = node.getID()
                print nodeID
                nodeOrder[nodeID] = m
                subNet[nodeID] = n
                distList.remove(distance(None,nodeID))
                for seg in nodeDict[node.getID()]:
                    for node in [seg.getNode1(), seg.getNode2()]:
                        nodeDict[node.getID()].remove(seg)
                m += 1
            n += 1
            if n == 5:
                break

        gp.addMessage("Writing data to shapefile...")
        # Copy projection information to shpProj.prj file for later use
        rootDir, fc = os.path.split(inputShapefile)
        base, ext =  os.path.splitext(fc)
        projFile = rootDir + os.sep + base + ".prj"
        outputShapefile = rootDir + os.sep + base + "nets" + ".shp"
        fileRW.genShapefile(tree, projFile, outputShapefile)
capacity=10
#root=network.Node(0, 452520.229406, 9445325.65803, 10)
'''root=network.Node(0,0,0,5)
households=[]
households.append(network.Node(1,0,2,1))
households.append(network.Node(2,1,2,1))
households.append(network.Node(3,-1,2,1))
households.append(network.Node(4,1,1,1))
households.append(network.Node(5,-1,1,1))
households.append(network.Node(6,2,1,1))
households.append(network.Node(7,1,4,1))
households.append(network.Node(8,-2,3,1))'''


households=[]
households.append(network.Node(0, 453143.895802, 9441304.74666, 1))
households.append(network.Node(1, 453141.369002, 9441342.64865, 1))
households.append(network.Node(2, 453176.112492, 9441319.90746, 1))
households.append(network.Node(3, 453062.406526, 9441304.74666, 1))
households.append(network.Node(4, 4453088.937918, 9441567.53378, 1))
households.append(network.Node(5, 452770.75615539739, 9445716.9034971781, 1))
households.append(network.Node(6, 452751.25842492335, 9445688.1985050924, 1))
households.append(network.Node(7, 452713.88777484809, 9445680.6160543524, 1))
households.append(network.Node(8, 452759.38247928751, 9445604.249943329, 1))
households.append(network.Node(9, 452783.75464238005, 9445863.1364757344, 1))



#CMST(households,capacity,root)

示例#9
0
def main(argv=None):
    if argv is None:
        argv = sys.argv
    try:
        try:
            opts, args = getopt.getopt(argv[1:], "h", ["help"])
        except getopt.GetoptError, msg:
            raise Usage(msg)
        if len(args) == 0:
            raise Usage("No arguments specified.")

        inputShapefile = argv[1]
        startPtShapefile = argv[2]
        outputShapefile = argv[3]
        nodeShapefile = argv[4]
        nodeShapefile1 = argv[5]
        lengthTable = argv[6]
        maxNodes = int(argv[7])

        gp.addMessage("Reading input nodes...")
        # Read nodes from input shapefile, creating network.Node instances.
        rows = gp.searchCursor(inputShapefile)
        row = rows.next()
        desc = gp.describe(inputShapefile)
        nodes = {}
        while row:
            feat = row.getValue(desc.ShapeFieldName)
            pnt = feat.getpart()
            # Read nodes.
            try:
                ptWeight = row.getValue("Weight")
            except:
                ptWeight = 1
            ptFID = row.getValue("FID")
            nodes[ptFID] = network.Node(ptFID, pnt.x, pnt.y, ptWeight)
            row = rows.next()
        del rows  # ensure cursor closes

        outputPath = os.path.dirname(outputShapefile)
        if not os.path.exists(outputPath):
            os.mkdir(outputPath)
        distFile = outputPath + os.sep + "dists.txt"
        nodeFile = outputPath + os.sep + "nodes.txt"

        # Copy projection information to shpProj.prj file for later use
        rootDir, fc = os.path.split(inputShapefile)
        base, ext = os.path.splitext(fc)
        projFile = rootDir + os.sep + base + ".prj"
        newProjFile = outputPath + os.sep + "shpProj.prj"
        try:
            if os.path.exists(newProjFile):
                os.remove(newProjFile)
            shutil.copy(projFile, newProjFile)
            projFile = newProjFile
        except WindowsError:
            gp.AddError("Could not find projection file")

        # Read starting point coordinates from the point in startPtShapefile
        rows = gp.searchCursor(startPtShapefile)
        desc = gp.describe(startPtShapefile)
        row = rows.next()
        feat = row.GetValue(desc.ShapeFieldName)
        FID = row.getValue("FID")
        point = feat.getPart(0)
        startNode = network.Node(FID, point.x, point.y, None)
        del rows

        firstNodeFID = nearestNode(startNode, nodes)

        gp.addMessage("Calculating tree...")
        tree = primsAlg(nodes, maxNodes, firstNodeFID)

        gp.addMessage("Writing output...")
        if os.path.exists(outputShapefile):
            gp.Delete_management(outputShapefile)
        fileRW.genShapefile(tree, projFile, outputShapefile)

        # Output a shapefile of the nodes in the network.
        if os.path.exists(nodeShapefile):
            gp.Delete_management(nodeShapefile)
        rootDir, fc = os.path.split(nodeShapefile)
        gp.CreateFeatureclass_management(rootDir, fc, "POINT")
        outDesc = gp.describe(nodeShapefile)
        shapefield = outDesc.ShapeFieldName
        origFIDField = "OrigFID"
        gp.addfield(nodeShapefile, origFIDField, "LONG")
        lengthField = "Length"
        gp.addfield(nodeShapefile, lengthField, "FLOAT")
        gp.deleteField_management(nodeShapefile, "Id")
        nodeRows = gp.insertCursor(nodeShapefile)
        point = gp.createobject("Point")
        for node in tree.getNodes():
            nodeFID = node.getID()
            sql = '"FID"=%i' % (nodeFID)
            rows = gp.searchCursor(inputShapefile, sql)
            oldRow = rows.next()
            row = nodeRows.newRow()
            row.setValue(origFIDField, nodeFID)
            row.setValue(lengthField, oldRow.getValue(lengthField))
            point.x = node.getX()
            point.y = node.getY()
            row.SetValue(shapefield, point)
            nodeRows.insertRow(row)
        del nodeRows
        del rows
        gp.defineprojection_management(nodeShapefile, projFile)
        if os.path.exists(nodeShapefile1):
            gp.Delete_management(nodeShapefile1)
        gp.CopyFeatures_management(nodeShapefile, nodeShapefile1)

        # Return a DBF with one field, the total length of the network.
        if os.path.exists(lengthTable):
            gp.Delete_management(lengthTable)
        rootDir, table = os.path.split(lengthTable)
        gp.CreateTable_management(rootDir, table)
        totalLenField = "totalLen"
        gp.addfield(lengthTable, totalLenField, "FLOAT")
        gp.deleteField(lengthTable, "Field1")
        rows = gp.insertCursor(lengthTable)
        row = rows.newRow()
        row.setValue(totalLenField, tree.getTotalEdgeWeight())
        rows.insertRow(row)
        del rows