Beispiel #1
0
def calculateShoreLength(gridFilePath, shoreFilePath, outFilePath):
    gridShp = shapelib.ShapeFile(gridFilePath)
    gridDbf = dbflib.DBFFile(gridFilePath.split('.')[0] + '.dbf')
    shoreShp = shapelib.ShapeFile(shoreFilePath)

    outShp = shapelib.create(outFilePath, shapelib.SHPT_POLYGON)
    outDbf = dbflib.create(outFilePath.split('.')[0] + '.dbf')
    outDbf.add_field("ID", dbflib.FTInteger, 10, 0)
    outDbf.add_field("Impact", dbflib.FTDouble, 30, 6)
    outDbf.add_field("Length", dbflib.FTDouble, 30, 6)

    inter = shoreShp.read_object(0).vertices()[1:]
    if inter:
        shoreGeo = Polygon(shoreShp.read_object(0).vertices()[0],
                           inter).boundary
    else:
        shoreGeo = Polygon(tuple(
            shoreShp.read_object(0).vertices()[0])).boundary

    for j in range(gridDbf.record_count()):
        gridObj = gridShp.read_object(j)
        gridGeo = Polygon(tuple(gridObj.vertices()[0]))

        shoreLength = gridGeo.intersection(shoreGeo).length
        recordDict = gridDbf.read_record(j)
        newDict = [j, recordDict["Impact"], shoreLength]
        outShp.write_object(-1, gridObj)
        outDbf.write_record(j, newDict)
Beispiel #2
0
def generateOSCOMInputs(rampFilePath, spillFilePath, containRadius,
                        distThreshold):
    rampShp = shapelib.ShapeFile(rampFilePath)
    rampDbf = dbflib.DBFFile(rampFilePath[:-4] +
                             '.dbf')  # rampFilePath.split('.')[0]
    spillShp = shapelib.ShapeFile(spillFilePath)
    spillDbf = dbflib.DBFFile(spillFilePath[:-4] +
                              '.dbf')  # spillFilePath.split('.')[0]

    vesCapList = []
    rampGeoList = []
    tn = rampDbf.record_count()
    for j in range(tn):
        rampObj = rampShp.read_object(j)
        rampGeo = Point(tuple(rampObj.vertices()[0]))
        rampGeoList.append(rampGeo)

        recordDict = rampDbf.read_record(j)
        vesCapList.append(recordDict['VesCap'])

    distDict = {}
    serveDict = {}
    coverDict = {}
    volumeList = []
    spillGeoList = []
    sn = spillDbf.record_count()

    for j in range(sn):
        serveDict[j] = []
        spillObj = spillShp.read_object(j)
        spillGeo = Point(tuple(spillObj.vertices()[0]))
        spillGeoList.append(spillGeo)

        recordDict = spillDbf.read_record(j)
        volumeList.append(recordDict['VOLUME_BBL'] * 42)

        for i in range(tn):
            dist = rampGeoList[i].distance(spillGeo)
            if dist <= distThreshold:
                distDict[(i, j)] = dist
                serveDict[j].append(i)

    servedDict = {}
    for i in range(tn):
        servedDict[i] = []
        for k, v in serveDict.items():
            if i in v:
                servedDict[i].append(k)

    for j in range(sn):
        coverDict[j] = []
        for l in range(sn):
            sdist = spillGeoList[j].distance(spillGeoList[l])
            if sdist <= containRadius:
                coverDict[j].append(l)

    print 'done'

    return [vesCapList, volumeList, distDict, serveDict, servedDict, coverDict]
Beispiel #3
0
    def read_shape_file(self, path):
        self.name = str(os.path.splitext(os.path.basename(path))[0])
        shp = shapelib.ShapeFile(path)
        shpinfo = shp.info()
        self.n = shpinfo[0]
        self.shp = shp

        if shpinfo[1] == shapelib.SHPT_POINT:
            self.shape_type = stars.SHP_POINT
        elif shpinfo[1] == shapelib.SHPT_POLYGON:
            self.shape_type = stars.SHP_POLYGON
        else:
            raise Exception("Shape type not support in CAST")

        self.extent = shpinfo[2][:2] + shpinfo[3][:2]
        self.centroids = coordinator.centroids(shp.cobject())
        self._shape_objects = coordinator.read_objects(shp.cobject(),
                                                       self.name)

        # load index
        self.locator = shptree.SHPTree(self.shp.cobject(), 2, 0)
        stars.SHAPE_LOCATOR_INDEX = stars.SHAPE_LOCATOR_QUADTREE
        #stars.SHAPE_LOCATOR_INDEX = None
        self.loadDBF(path)

        self.get_kdtree_locator()
Beispiel #4
0
def AddBoomField(gridFilePath, sol, outFilePath):
    gridSHP = shapelib.ShapeFile(gridFilePath)
    gridDBF = dbflib.DBFFile(gridFilePath.split('.')[0] + '.dbf')

    outSHP = shapelib.create(outFilePath, shapelib.SHPT_POLYGON)
    outDBF = dbflib.create(outFilePath.split('.')[0] + '.dbf')

    for j in range(gridDBF.field_count()):
        #if j == 17:
        #outDBF.add_field(gridDBF.field_info(j)[1], dbflib.FTDouble, 20, 10)
        #else:
        outDBF.add_field(
            gridDBF.field_info(j)[1],
            gridDBF.field_info(j)[0],
            gridDBF.field_info(j)[2],
            gridDBF.field_info(j)[3])

    outDBF.add_field('Boomed', dbflib.FTInteger, 5, 0)

    jj = 0
    for j in range(gridDBF.record_count()):
        vert = gridSHP.read_object(j)
        recordDict = gridDBF.read_record(j)

        if j in sol:
            recordDict['Boomed'] = 1
        else:
            recordDict['Boomed'] = 0

        outSHP.write_object(-1, vert)
        outDBF.write_record(jj, recordDict)
        jj += 1
Beispiel #5
0
def LoadShapefile(filename, shpNature, hostObject):
    # The shapelib object
    shp = []
    # open the shapefile
    if os.path.isfile(filename):
        (dirname, filerelname) = os.path.split(filename)
        (bodyname, fileext) = os.path.splitext(filerelname)
        logging.info('(DD) Is FILE OK')
        # In order to open a shapefile the shapelib needs to have the shx corresponding files
        if os.path.isfile(os.path.join(
                dirname, bodyname + '.SHX')) or os.path.isfile(
                    os.path.join(dirname, bodyname + '.shx')):
            logging.info('(DD) IS SHALELIB OK')
            shp = shapelib.ShapeFile(filename)
    else:
        return 0

    if shp:
        Tshp = (shp.info())[1]
        logging.info('(II) Reading shapefile with type ', Tshp, ' contents (',
                     filerelname, ') as ', shpNature)
        #-------- Loading Roads
        if (shpNature >= 20) and (shpNature <= 29):
            LoadRoads(shp, hostObject)
        #-------- Loading Buildings
        if (shpNature >= 30) and (shpNature <= 39):
            LoadBuildings(shp, hostObject)
Beispiel #6
0
def generateMCLPInputsGrid(rampFilePath, gridFilePath, distThreshold):
    rampShp = shapelib.ShapeFile(rampFilePath)
    rampDbf = dbflib.DBFFile(rampFilePath.split('.')[0] + '.dbf')
    gridShp = shapelib.ShapeFile(gridFilePath)
    gridDbf = dbflib.DBFFile(gridFilePath.split('.')[0] + '.dbf')

    rampGeoList = []
    tn = rampDbf.record_count()
    for j in range(tn):
        rampObj = rampShp.read_object(j)
        rampGeo = Point(tuple(rampObj.vertices()[0]))
        rampGeoList.append(rampGeo)

        recordDict = rampDbf.read_record(j)

    distDict = {}
    serveDict = {}
    gridLenList = []
    gridSenList = []
    gridGeoList = []
    sn = gridDbf.record_count()

    for j in range(sn):
        serveDict[j] = []
        gridObj = gridShp.read_object(j)
        gridGeo = Polygon(tuple(gridObj.vertices()[0])).centroid
        gridGeoList.append(gridGeo)

        recordDict = gridDbf.read_record(j)
        gridSenList.append(recordDict['Total_S'])

        for i in range(tn):
            dist = rampGeoList[i].distance(gridGeo)
            if dist <= distThreshold:
                distDict[(i, j)] = dist
                serveDict[j].append(i)

    servedDict = {}
    for i in range(tn):
        servedDict[i] = []
        for k, v in serveDict.items():
            if i in v:
                servedDict[i].append(k)

    print 'done'
    return [gridSenList, serveDict, servedDict]
Beispiel #7
0
def generateMCLPInputs(rampFilePath, shoreFilePath, distThreshold):
    rampShp = shapelib.ShapeFile(rampFilePath)
    rampDbf = dbflib.DBFFile(rampFilePath.split('.')[0] + '.dbf')
    shoreShp = shapelib.ShapeFile(shoreFilePath)
    shoreDbf = dbflib.DBFFile(shoreFilePath.split('.')[0] + '.dbf')

    rampGeoList = []
    tn = rampDbf.record_count()
    for j in range(tn):
        rampObj = rampShp.read_object(j)
        rampGeo = Point(tuple(rampObj.vertices()[0]))
        rampGeoList.append(rampGeo)

        recordDict = rampDbf.read_record(j)

    distDict = {}
    serveDict = {}
    shoreSenList = []
    shoreGeoList = []
    sn = shoreDbf.record_count()

    for j in range(sn):
        serveDict[j] = []
        shoreObj = shoreShp.read_object(j)
        shoreGeo = LineString(tuple(shoreObj.vertices()[0])).centroid
        shoreGeoList.append(shoreGeo)

        recordDict = shoreDbf.read_record(j)
        shoreSenList.append(recordDict['ESI_1'])

        for i in range(tn):
            dist = rampGeoList[i].distance(shoreGeo)
            if dist <= distThreshold:
                distDict[(i, j)] = dist
                serveDict[j].append(i)

    servedDict = {}
    for i in range(tn):
        servedDict[i] = []
        for k, v in serveDict.items():
            if i in v:
                servedDict[i].append(k)

    print 'done'
    return [shoreSenList, serveDict, servedDict]
Beispiel #8
0
def createPointFast(filePath):
    shpList = []
    shp = shapelib.ShapeFile(filePath)
    dbf = dbflib.DBFFile(filePath.split('.')[0] + '.dbf')
    for j in range(dbf.record_count()):
        geo = Point(tuple(shp.read_object(j).vertices()[0]))
        shpList.append(geo)

    return shpList
Beispiel #9
0
def generatEBAMInputs(rampFilePath, gridFilePath, speed, hitDay):
    rampShp = shapelib.ShapeFile(rampFilePath)
    rampDbf = dbflib.DBFFile(rampFilePath.split('.')[0] + '.dbf')
    gridShp = shapelib.ShapeFile(gridFilePath)
    gridDbf = dbflib.DBFFile(gridFilePath.split('.')[0] + '.dbf')

    ebCap = []
    rampGeoList = []
    cdDict = {}
    tn = rampDbf.record_count()
    for j in range(tn):
        rampObj = rampShp.read_object(j)
        rampGeo = Point(tuple(rampObj.vertices()[0]))
        rampGeoList.append(rampGeo)

        recordDict = rampDbf.read_record(j)
        ebCap.append(recordDict['EBCap_Mete'])
        cdDict[j] = []

    distDict = {}
    coverDict = {}
    impactList = []
    needBoomList = []
    for j in range(gridDbf.record_count()):
        gridObj = gridShp.read_object(j)
        gridGeo = Polygon(tuple(gridObj.vertices()[0]))
        recordDict = gridDbf.read_record(j)

        impactList.append(recordDict['Impact'])
        needBoomList.append(recordDict['Length'])
        coverDict[j] = []

        for i in range(tn):
            dist = rampGeoList[i].distance(gridGeo)
            hours = dist / speed

            if hours <= hitDay * 24:
                coverDict[j].append(i)
                cdDict[i].append(j)
                distDict[(i, j)] = dist

    return [ebCap, impactList, needBoomList, distDict, coverDict, cdDict]
Beispiel #10
0
def createPolygonFastNoInterior(filePath):
    shpList = []
    shp = shapelib.ShapeFile(filePath)
    dbf = dbflib.DBFFile(filePath.split('.')[0] + '.dbf')

    for j in range(dbf.record_count()):
        inter = shp.read_object(j).vertices()[1:]

        geo = Polygon(tuple(shp.read_object(j).vertices()[0]))

        shpList.append(geo.buffer(0))

    return shpList
Beispiel #11
0
def read_shapefile(filename):
    # open the shapefile
    shp = shapelib.ShapeFile(filename)

    # the info method returns a tuple (num_shapes, type, min, max) where
    # num_shapes is the number of shapes, type is the type code (one of
    # the SHPT* constants defined in the shapelib module) and min and
    # max are 4-element lists with the min. and max. values of the
    # vertices.
    print shp.info()

    # read_object reads a shape
    obj = shp.read_object(0)

    # The vertices method returns the shape as a list of lists of tuples.
    print obj.vertices()[0][:10]

    # The extents returns a tuple with two 4-element lists with the min.
    # and max. values of the vertices.
    print obj.extents()

    # The type attribute is the type code (one of the SHPT* constants
    # defined in the shapelib module)
    print obj.type

    # The id attribute is the shape id
    print obj.id

    # the cobject method returns a PyCObject containing the shapelib
    # SHPHandle. This is useful for passing shapefile objects to
    # C-Python extensions.
    print shp.cobject()

    # build a quad tree from the shapefile. The first argument must be
    # the return value of the shape file object's cobject method (this
    # is currently needed to access the shape file at the C-level). The
    # second argument is the dimension and the third the maximum depth.
    # 0 means to guess an appropriate depth
    tree = shptree.SHPTree(shp.cobject(), 2, 0)

    # Retrieve the ids for a region. Here we just use the extents of the
    # object previously read from the shapefile
    minima, maxima = obj.extents()
    print tree.find_shapes(minima[:2], maxima[:2])
Beispiel #12
0
def simulateRampCapacity(rampFilePath, outFilePath):
    rampShp = shapelib.ShapeFile(rampFilePath)
    rampDbf = dbflib.DBFFile(rampFilePath.split('.')[0] + '.dbf')

    outShp = shapelib.create(outFilePath, shapelib.SHPT_POINT)
    outDbf = dbflib.create(outFilePath.split('.')[0] + '.dbf')
    outDbf.add_field("ID", dbflib.FTInteger, 10, 0)
    outDbf.add_field("EBCap", dbflib.FTInteger, 30, 0)
    outDbf.add_field("VesCap", dbflib.FTInteger, 10, 0)

    tn = rampDbf.record_count()
    ebCap = randint(500, high=5001, size=tn)
    vesCap = choice(6, tn, p=[0.5, 0.2, 0.1, 0.1, 0.05, 0.05])

    for j in range(tn):
        rampObj = rampShp.read_object(j)
        recordDict = rampDbf.read_record(j)

        newDict = [j, ebCap[j], vesCap[j]]
        outShp.write_object(-1, rampObj)
        outDbf.write_record(j, newDict)
 def clear_small_polygons(self, shapeFile, newShapeFile, lenLimit):
     shp = shapelib.ShapeFile(shapeFile)
     dbf = dbflib.open(shapeFile)
     newSHP = shapelib.create(newShapeFile, self.shpType)
     newDBF = dbflib.create(newShapeFile)
     for f in range(dbf.field_count()):
         fi = dbf.field_info(f)
         newDBF.add_field(fi[1], fi[0], fi[2], fi[3])
     bb = 0
     for b in range(shp.info()[0]):
         sobj = shp.read_object(b)
         rec = dbf.read_record(b)
         if self.length_of_polygon(sobj.vertices()) > lenLimit:
             shpobj = shapelib.SHPObject(self.shpType, bb,
                                         [sobj.vertices()[0]])
             newSHP.write_object(bb, shpobj)
             newDBF.write_record(bb, rec)
             bb += 1
     shp.close()
     dbf.close()
     newSHP.close()
     newDBF.close()
 def __init__(self, buildingSHPFile):
     self.buildingSHPFile = buildingSHPFile
     self.shp = shapelib.ShapeFile(buildingSHPFile)
     self.shpNum, self.shpType = self.shp.info()[0], self.shp.info()[1]