Пример #1
0
def sampleGrid(gridfile,geodict):
    xdim,ydim = getFileResolution(gridfile)
    resolution = np.mean([xdim,ydim])
    xmin = geodict['xmin']
    xmax = geodict['xmax']
    ymin = geodict['ymin']
    ymax = geodict['ymax']
    #resolution = geodict['xdim']
    bounds = (xmin-(resolution*2),xmax+(resolution*2),ymin-(resolution*2),ymax+(resolution*2))
    if gridfile.endswith('grd'):
        grid = GMTGrid(grdfile=gridfile,bounds=bounds)
    else:
        tmpgrid = EsriGrid(gridfile)
        tmpgrid.load(bounds=bounds)
        grid = GMTGrid()
        grid.loadFromGrid(tmpgrid)
    grid.interpolateToGrid(geodict)
    return grid
Пример #2
0
def main(args):
    #define location for config file
    homedir = os.path.expanduser("~") #where is the user's home directory?
    configfile = args.configFile
    
    shakefile = args.shakefile

    if not os.path.isfile(shakefile):
        if isURL(shakefile):
            shakefile = getGridURL(shakefile) #returns a file object
        else:
            print 'Could not find "%s" as a file or a url.  Returning.' % (shakefile)
    
    shakemap = ShakeGrid(shakefile)
    #figure out the bounds that are greater than the biggest bounds
    #of any of the grids
    shakerange = shakemap.getRange()
    lonrange = shakerange[1] - shakerange[0]
    latrange = shakerange[3] - shakerange[2]
    xmin = shakerange[0] - lonrange*0.1
    xmax = shakerange[1] + lonrange*0.1
    ymin = shakerange[2] - latrange*0.1
    ymax = shakerange[3] + latrange*0.1
    bigbounds = (xmin,xmax,ymin,ymax)
    #
    shakeheader = shakemap.getAttributes()
    edict = {'mag':shakeheader['event']['magnitude'],
             'time':shakeheader['event']['event_timestamp'],
             'loc':shakeheader['event']['event_description'],
             'epicenter':(shakeheader['event']['lat'],shakeheader['event']['lon']),
             'version':int(shakeheader['shakemap_grid']['shakemap_version']),
             'eventid':shakeheader['shakemap_grid']['event_id']}
    config = ConfigParser.RawConfigParser()
    config.read(configfile)
    network = shakeheader['shakemap_grid']['shakemap_originator']
    eventcode =  shakeheader['shakemap_grid']['shakemap_id']
    if eventcode.startswith(network):
        eventid = eventcode
    else:
        eventid = network + eventcode
    outfolder = os.path.join(config.get('OUTPUT','folder'),eventid)
    if not os.path.isdir(outfolder):
        os.makedirs(outfolder)

    slopefile = config.get('MAPDATA','slope')
    slopegrid = GMTGrid(slopefile,bounds=shakemap.getRange())
    slopeout = os.path.join(outfolder,'slope.grd')

    cityfile = config.get('MAPDATA','cityfile')
    
    #get all of the colors that people want
    colors = {}
    for option in config.options('MAPDATA'):
        if option.endswith('color'):
            colors[option] = config.get('MAPDATA',option)

    #if they have roads configured, go find the appropriate roads segments
    hasRoads = config.has_option('MAPDATA','roadfolder')
    roadslist = []
    if hasRoads and args.roads:
        roadroot = config.get('MAPDATA','roadfolder')
        xmin,xmax,ymin,ymax = shakemap.getRange()
        for folder in os.listdir(roadroot):
            roadfolder = os.path.join(roadroot,folder)
            shpfiles = glob.glob(os.path.join(roadfolder,'*.shp'))
            if len(shpfiles):
                shpfile = shpfiles[0]
                f = fiona.open(shpfile)
                shapes = list(f.items(bbox=(xmin,ymin,xmax,ymax)))
                for shapeid,shapedict in shapes:
                    roadslist.append(shapedict)
                f.close()

    #get the thresholds for liquefaction/landslide model
    slopemin = float(config.get('MAPDATA','slopemin'))*100
    slopemax = float(config.get('MAPDATA','slopemax'))*100
    
    probdict = {}
    gridbounds = [999,-999,999,-999] #this will hold the smallest bounding box enclosing both models
    for model in getModelNames(configfile):
        lm = LogisticModel(configfile,shakefile,model)
        colormaps = getColorMaps(configfile)
        print 'Equation for %s model:' % model
        print 
        print lm.getEquation()
        print
        P = lm.calculate()
        probgrid = GMTGrid()
        probgrid.griddata = P.copy()
        probgrid.geodict = lm.layerdict[lm.layerdict.keys()[0]].geodict.copy()

        #resample the slope grid to model
        slopegrid2 = GMTGrid()
        slopegrid2.loadFromGrid(slopegrid)
        slopegrid2.interpolateToGrid(probgrid.geodict)

        if model == 'liquefaction':
            ithresh = slopegrid2.griddata > slopemax
        else:
            ithresh = slopegrid2.griddata < slopemin

        probgrid.griddata[ithresh] = 0.0
        
        xmin,xmax,ymin,ymax = probgrid.getRange()
        if xmin < gridbounds[0]:
            gridbounds[0] = xmin
        if xmax > gridbounds[1]:
            gridbounds[1] = xmax
        if ymin < gridbounds[2]:
            gridbounds[2] = ymin
        if ymax > gridbounds[3]:
            gridbounds[3] = ymax
        probdict[model] = probgrid
        probfile = os.path.join(outfolder,'%s.grd' % model)
        print 'Saving %s model output to %s' % (model,probfile)
        probgrid.save(probfile)
        #renderPanel(lm,colormaps,outfolder,edict)
        # for layername,layergrid in lm.layerdict.iteritems():
        #     layerfile = os.path.join(outfolder,layername+'.grd')
        #     print 'Saving input grid %s to %s...' % (layername,layerfile)
        #     layergrid.save(layerfile)
        #     renderLayer(layergrid,layername,outfolder,edict,model,colormaps)

    topofile = config.get('MAPDATA','topo')
    #bigbounds = shakemap.getRange()
    xdim = shakemap.geodict['xdim']
    ydim = shakemap.geodict['xdim']
    #bigbounds = (bigbounds[0]-xdim*4,bigbounds[1]+xdim*4,bigbounds[2]-ydim*4,bigbounds[3]+ydim*4)
    topogrid = GMTGrid(topofile,bounds=bigbounds)
    topogrid = adjustTopoGrid(topogrid,bigbounds) #make this grid as big as bigbounds if we hit an upper or lower bound
    topoout = os.path.join(outfolder,'topography.grd')
    print 'Saving topography to %s' % topoout
    topogrid.save(topoout)
    
    print 'Saving slope to %s' % slopeout
    slopegrid.save(slopeout)

    isScenario = shakeheader['shakemap_grid']['shakemap_event_type'].lower() == 'scenario'
    if args.noscenario:
        isScenario = False
    timestr = renderDate(shakeheader['event']['event_timestamp'])
    location = shakeheader['event']['event_description']
    #hillshfile = config.get('MAPDATA','hillshadefile')
    #hillshgrid = GMTGrid(hillshfile,bounds=bigbounds)
    makeDualMap(probdict['liquefaction'],probdict['landslide'],topogrid,slopegrid,edict,outfolder,isScenario=isScenario,roadslist=roadslist,colors=colors,cityfile=cityfile)
Пример #3
0
def makeDualMap(
    lqgrid, lsgrid, topogrid, slopegrid, eventdict, outfolder, isScenario=False, roadslist=[], colors={}, cityfile=None
):
    # create the figure and axes instances.
    fig = plt.figure()
    ax = fig.add_axes([0.1, 0.1, 0.8, 0.8])
    # setup of basemap ('lcc' = lambert conformal conic).
    # use major and minor sphere radii from WGS84 ellipsoid.
    xmin, xmax, ymin, ymax = topogrid.getRange()
    clat = ymin + (ymax - ymin) / 2.0
    clon = xmin + (xmax - xmin) / 2.0
    m = Basemap(
        llcrnrlon=xmin,
        llcrnrlat=ymin,
        urcrnrlon=xmax,
        urcrnrlat=ymax,
        rsphere=(6378137.00, 6356752.3142),
        resolution="h",
        area_thresh=1000.0,
        projection="lcc",
        lat_1=clat,
        lon_0=clon,
        ax=ax,
    )

    clear_color = [0, 0, 0, 0.0]

    # topoextent = getGridExtent(topogrid,m)
    # rgb,topopalette = getTopoRGB(topogrid)
    # color_tuple = rgb.transpose((1,0,2)).reshape((rgb.shape[0]*rgb.shape[1],rgb.shape[2]))/255.0

    hillsh = hillshade(topogrid, 315, 50)  # divide by 2 to mute colors
    topogrid2 = GMTGrid()
    topogrid2.loadFromGrid(topogrid)
    topogrid2.interpolateToGrid(lqgrid.geodict)
    # define what cells are below sea level
    iwater = np.where(topogrid2.griddata == SEA_LEVEL)

    lons = np.arange(xmin, xmax, topogrid.getGeoDict()["xdim"])
    lons = lons[: topogrid.getGeoDict()["ncols"]]  # make sure right length
    lats = np.arange(ymax, ymin, -topogrid.getGeoDict()["ydim"])  # backwards so it plots right
    lats = lats[: topogrid.getGeoDict()["nrows"]]
    llons, llats = np.meshgrid(lons, lats)  # make meshgrid
    x, y = m(llons, llats)  # get projection coordinates
    im = m.pcolormesh(x, y, hillsh, cmap="Greys", lw=0, vmin=0.0, vmax=550.0, rasterized=True)
    # im = m.imshow(rgb,cmap=topopalette,extent=topoextent)

    # figure out the aspect ratio of the axes
    print "Map width: %s" % commify(int(m.xmax - m.xmin))
    print "Map height: %s" % commify(int(m.ymax - m.ymin))
    aspect = (m.xmax - m.xmin) / (m.ymax - m.ymin)
    slope = -0.33
    intercept = 0.463
    leftx = slope * aspect + intercept
    print "Left edge of left colorbar is at: %.2f" % leftx
    slope = 20.833
    intercept = -0.833
    titlex = slope * aspect + intercept
    print "Title X of right colorbar is at: %.2f" % titlex

    # this business apparently has to happen after something has been
    # rendered on the map, which I guess makes sense.
    # draw the map ticks on outside of all edges
    fig.canvas.draw()  # have to do this for tick stuff to show
    xticks, xlabels, yticks, ylabels = getMapTicks(m, xmin, xmax, ymin, ymax)
    plt.sca(ax)
    plt.tick_params(axis="both", direction="in", right="on", colors="white")
    plt.xticks(xticks, xlabels, size=8)
    plt.yticks(yticks, ylabels, size=8)
    for tick in ax.axes.yaxis.get_major_ticks():
        tick.set_pad(-38)
        tick.label2.set_horizontalalignment("right")
    for tick in ax.axes.xaxis.get_major_ticks():
        tick.set_pad(-15)
        tick.label2.set_verticalalignment("top")
    [i.set_color("white") for i in plt.gca().get_xticklabels()]
    [i.set_color("white") for i in plt.gca().get_yticklabels()]

    # render liquefaction
    lqdat = lqgrid.getData().copy() * 100.0

    palettelq = cm.autumn_r
    i = np.where(lqdat < 2.0)
    lqdat[i] = 0
    lqdat[iwater] = 0
    lqdatm = np.ma.masked_equal(lqdat, 0)
    palettelq.set_bad(clear_color, alpha=0.0)

    xmin, xmax, ymin, ymax = lqgrid.getRange()
    lons = np.arange(xmin, xmax, lqgrid.getGeoDict()["xdim"])
    lons = lons[
        : lqgrid.getGeoDict()["ncols"]
    ]  # make sure it's the right length, sometimes it is one too long, sometimes it isn't because of GMTGrid issue
    lats = np.arange(ymax, ymin, -lqgrid.getGeoDict()["ydim"])  # backwards so it plots right side up
    lats = lats[
        : lqgrid.getGeoDict()["nrows"]
    ]  # make sure it's the right length, sometimes it is one too long, sometimes it isn't because of GMTGrid issue
    # make meshgrid
    llons, llats = np.meshgrid(lons, lats)
    x, y = m(llons, llats)  # get projection coordinates
    lqprobhandle = m.pcolormesh(x, y, lqdatm, lw=0, cmap=palettelq, vmin=2.0, vmax=20.0, alpha=ALPHA, rasterized=True)
    # extent = getGridExtent(lqgrid,m)
    # lqprobhandle = m.imshow(lqdatm,cmap=palettelq,vmin=2.0,vmax=20.0,alpha=ALPHA,origin='upper',extent=extent)
    norm = mpl.colors.Normalize(vmin=2.0, vmax=20.0)
    cbarlq = m.colorbar(mappable=lqprobhandle, norm=norm, cmap=palettelq)
    cbarlq.solids.set_rasterized(True)
    # cbarlq.solids.set_edgecolor("face")
    # plt.draw()
    cbarlq.set_ticks([2.0, 11.0, 19.0])
    cbarlq.set_ticklabels(["Low", "Medium", "High"])  # vertically oriented colorbar

    # render landslide
    topogrid2 = GMTGrid()
    topogrid2.loadFromGrid(topogrid)
    topogrid2.interpolateToGrid(lsgrid.geodict)
    lsdat = lsgrid.getData().copy() * 100.0
    clear_color = [0, 0, 0, 0.0]
    palettels = cm.cool
    i = np.where(lsdat < 2.0)
    lsdat[i] = 0
    lsdat[iwater] = 0
    lsdatm = np.ma.masked_equal(lsdat, 0)
    palettels.set_bad(clear_color, alpha=0.0)

    xmin, xmax, ymin, ymax = lsgrid.getRange()
    lons = np.arange(xmin, xmax, lsgrid.getGeoDict()["xdim"])
    lons = lons[
        : lsgrid.getGeoDict()["ncols"]
    ]  # make sure it's the right length, sometimes it is one too long, sometimes it isn't because of GMTGrid issue
    lats = np.arange(ymax, ymin, -lsgrid.getGeoDict()["ydim"])  # backwards so it plots right side up
    # make meshgrid
    lats = lats[: lsgrid.getGeoDict()["nrows"]]
    llons, llats = np.meshgrid(lons, lats)
    x, y = m(llons, llats)  # get projection coordinates
    lsprobhandle = m.pcolormesh(x, y, lsdatm, lw=0, cmap=palettels, vmin=2.0, vmax=20.0, alpha=ALPHA, rasterized=True)
    # extent = getGridExtent(lsgrid,m)
    # lsprobhandle = plt.imshow(lsdatm,cmap=palettels,vmin=2.0,vmax=20.0,alpha=ALPHA,origin='upper',extent=extent)

    # draw landslide colorbar on the left side
    axleft = fig.add_axes([leftx, 0.1, 0.033, 0.8])
    norm = mpl.colors.Normalize(vmin=2.0, vmax=20.0)
    cbarls = mpl.colorbar.ColorbarBase(axleft, cmap=palettels, norm=norm, orientation="vertical")
    cbarls.solids.set_rasterized(True)
    cbarls.ax.yaxis.set_ticks_position("left")
    cbarls.set_ticks([2.0, 11.0, 19.0])
    cbarls.set_ticklabels(["Low", "Medium", "High"])  # vertically oriented colorbar

    # draw roads on the map, if they were provided to us
    roadcolor = ROADCOLOR
    if colors.has_key("roadcolor"):
        roadcolor = "#" + colors["roadcolor"]
    for road in roadslist:
        xy = list(road["geometry"]["coordinates"])
        roadx, roady = zip(*xy)
        mapx, mapy = m(roadx, roady)
        m.plot(mapx, mapy, roadcolor, lw=1.0)

    # add city names to map with population >50,000 (add option later)
    if cityfile is not None:
        dmin = 0.04 * (m.ymax - m.ymin)
        xyplotted = []
        cities = PagerCity(cityfile)
        # Find cities within bounding box
        boundcity = cities.findCitiesByRectangle(bounds=(xmin, xmax, ymin, ymax))
        # Just keep 7 biggest cities
        thresh = sorted([cit["pop"] for cit in boundcity])[-7]
        plotcity = [cit for cit in boundcity if cit["pop"] >= thresh]
        # For cities that are more than one xth of the xwidth apart, keep only the larger one
        pass  # do later
        # Plot cities
        for (
            cit
        ) in (
            plotcity
        ):  # should sort so it plots them in order of population so larger cities are preferentially plotted - do later
            xi, yi = m(cit["lon"], cit["lat"])
            dist = [np.sqrt((xi - x0) ** 2 + (yi - y0) ** 2) for x0, y0 in xyplotted]
            if not dist or np.min(dist) > dmin:
                m.scatter(cit["lon"], cit["lat"], c="k", latlon=True, marker=".")
                ax.text(xi, yi, cit["name"], ha="right", va="top", fontsize=8)
                xyplotted.append((xi, yi))

    # draw titles
    cbartitle_ls = "Landslide\nProbability"
    plt.text(-1.0, 1.03, cbartitle_ls, multialignment="left", axes=ax)

    cbartitle_ls = "Liquefaction\nProbability"
    plt.text(titlex, 1.03, cbartitle_ls, multialignment="left", axes=ax)

    axwidth = 20  # where can I get this from?

    # draw a map boundary, fill in oceans with water
    # water_color = [.47,.60,.81] # too similar to a blue shade in ls colorbar
    water_color = "#B8EEFF"
    m.drawmapboundary(fill_color=water_color)

    if isScenario:
        title = eventdict["loc"]
    else:
        timestr = eventdict["time"].strftime("%b %d %Y")
        title = "M%.1f %s v%i\n %s" % (eventdict["mag"], timestr, eventdict["version"], eventdict["loc"])

    # draw the title on the plot
    ax.set_title(title)

    # draw star at epicenter
    plt.sca(ax)
    elat, elon = eventdict["epicenter"]
    ex, ey = m(elon, elat)
    plt.plot(ex, ey, "*", markeredgecolor="k", mfc="None", mew=1.5, ms=24)

    # fill in the lakes and rivers
    m.fillcontinents(color=clear_color, lake_color=water_color)
    m.drawrivers(color=water_color)

    # draw country boundaries
    countrycolor = COUNTRYCOLOR
    if colors.has_key("countrycolor"):
        countrycolor = "#" + colors["countrycolor"]
    m.drawcountries(color=countrycolor, linewidth=1.0)

    # add map scale
    m.drawmapscale(
        (xmax + xmin) / 2,
        (ymin + (ymax - ymin) / 150),
        clon,
        clat,
        np.round((((xmax - xmin) * 110) / 5) / 10.0) * 10,
        barstyle="fancy",
    )
    # draw coastlines
    m.drawcoastlines(color="#476C91", linewidth=0.5)

    # draw scenario watermark, if scenario
    if isScenario:
        plt.sca(ax)
        cx, cy = m(clon, clat)
        plt.text(cx, cy, "SCENARIO", rotation=45, alpha=0.10, size=72, ha="center", va="center", color="red")

    # plt.title(ptitle,axes=ax)
    outfile = os.path.join(outfolder, "%s.pdf" % eventdict["eventid"])
    pngfile = os.path.join(outfolder, "%s.png" % eventdict["eventid"])
    plt.savefig(outfile)
    plt.savefig(pngfile)
    print "Saving map output to %s" % outfile
    print "Saving map output to %s" % pngfile