def calc_slope(elevation): """Calculates slope angle in percent using r.slope.aspect Parameters ---------- elevation : str Name of the GRASS raster map with the elevation data. Returns ------- slope : str Name of the output slope map. """ slope = rand_id("slope{}".format(L + 1)) TMP_RAST[L].append(slope) r.slope_aspect(elevation=elevation, slope=slope, flags="e", format="percent", quiet=True) return slope
def main(): # user specified variables dem = options["elevation"] slope = options["slope"] aspect = options["aspect"] neighborhood_size = options["size"] output = options["output"] nprocs = int(options["nprocs"]) exponent = float(options["exponent"]) # check for valid neighborhood sizes neighborhood_size = neighborhood_size.split(",") neighborhood_size = [int(i) for i in neighborhood_size] if any([True for i in neighborhood_size if i % 2 == 0]): gs.fatal( "Invalid size - neighborhood sizes have to consist of odd numbers") if min(neighborhood_size) == 1: gs.fatal("Neighborhood sizes have to be > 1") # determine nprocs if nprocs < 0: n_cores = mp.cpu_count() nprocs = n_cores - (nprocs + 1) # temporary raster map names for slope, aspect, x, y, z components if slope == "": slope_raster = create_tempname("tmpSlope_") else: slope_raster = slope if aspect == "": aspect_raster = create_tempname("tmpAspect_") else: aspect_raster = aspect z_raster = create_tempname("tmpzRaster_") x_raster = create_tempname("tmpxRaster_") y_raster = create_tempname("tmpyRaster_") # create slope and aspect rasters if slope == "" or aspect == "": gs.message("Calculating slope and aspect...") gr.slope_aspect( elevation=dem, slope=slope_raster, aspect=aspect_raster, format="degrees", precision="FCELL", zscale=1.0, min_slope=0.0, quiet=True, ) # calculate x y and z rasters # note - GRASS sin/cos functions differ from ArcGIS which expects input grid in radians # whereas GRASS functions expect degrees # no need to convert slope and aspect to radians as in the original ArcGIS script x_expr = "{x} = float( sin({a}) * sin({b}) )".format(x=x_raster, a=aspect_raster, b=slope_raster) y_expr = "{y} = float( cos({a}) * sin({b}) )".format(y=y_raster, a=aspect_raster, b=slope_raster) z_expr = "{z} = float( cos({a}) )".format(z=z_raster, a=slope_raster) # calculate x, y, z components (parallel) gs.message("Calculating x, y, and z rasters...") mapcalc = Module("r.mapcalc", run_=False) queue = ParallelModuleQueue(nprocs=nprocs) mapcalc1 = copy.deepcopy(mapcalc) m = mapcalc1(expression=x_expr) queue.put(m) mapcalc2 = copy.deepcopy(mapcalc) m = mapcalc2(expression=y_expr) queue.put(m) mapcalc3 = copy.deepcopy(mapcalc) m = mapcalc3(expression=z_expr) queue.put(m) queue.wait() # calculate x, y, z neighborhood sums (parallel) gs.message( "Calculating sums of x, y, and z rasters in selected neighborhoods...") x_sum_list = [] y_sum_list = [] z_sum_list = [] neighbors = Module("r.neighbors", overwrite=True, run_=False) queue = ParallelModuleQueue(nprocs=nprocs) for size in neighborhood_size: # create temporary raster names for neighborhood x, y, z sums x_sum_raster = create_tempname("tmpxSumRaster_") x_sum_list.append(x_sum_raster) y_sum_raster = create_tempname("tmpySumRaster_") y_sum_list.append(y_sum_raster) z_sum_raster = create_tempname("tmpzSumRaster_") z_sum_list.append(z_sum_raster) # create weights mat = idw_weights(size, exponent) # queue jobs for x, y, z neighborhood sums neighbors_xsum = copy.deepcopy(neighbors) n = neighbors_xsum( input=x_raster, output=x_sum_raster, method="average", size=size, weight=mat, stdin=mat, ) queue.put(n) neighbors_ysum = copy.deepcopy(neighbors) n = neighbors_ysum( input=y_raster, output=y_sum_raster, method="average", size=size, weight=mat, ) queue.put(n) neighbors_zsum = copy.deepcopy(neighbors) n = neighbors_zsum( input=z_raster, output=z_sum_raster, method="average", size=size, weight=mat, ) queue.put(n) queue.wait() # calculate the resultant vector and final ruggedness raster # modified from the original script to multiple each SumRaster by the n neighborhood # cells to get the sum gs.message("Calculating the final ruggedness rasters...") mapcalc = Module("r.mapcalc", run_=False) queue = ParallelModuleQueue(nprocs=nprocs) vrm_list = [] for x_sum_raster, y_sum_raster, z_sum_raster, size in zip( x_sum_list, y_sum_list, z_sum_list, neighborhood_size): if len(neighborhood_size) > 1: vrm_name = "_".join([output, str(size)]) else: vrm_name = output vrm_list.append(vrm_name) vrm_expr = "{x} = float(1-( (sqrt(({a}*{d})^2 + ({b}*{d})^2 + ({c}*{d})^2) / {d})))".format( x=vrm_name, a=x_sum_raster, b=y_sum_raster, c=z_sum_raster, d=int(size) * int(size), ) mapcalc1 = copy.deepcopy(mapcalc) m = mapcalc1(expression=vrm_expr) queue.put(m) queue.wait() # set colors gr.colors(flags="e", map=vrm_list, color="ryb") # set metadata for vrm, size in zip(vrm_list, neighborhood_size): title = "Vector Ruggedness Measure (size={size})".format(size=size) gr.support(map=vrm, title=title) return 0
streams=streams_all, streams_modflow=streams_MODFLOW, dem_modflow=DEM_MODFLOW, overwrite=True) # GSFLOW reaches: intersection of segments and grid v.gsflow_reaches(segment_input=segments, grid_input=MODFLOW_grid, elevation=DEM, output=reaches, overwrite=True) # GSFLOW HRU parameters r.slope_aspect(elevation=DEM, slope=slope, aspect=aspect, format='percent', zscale=0.01, overwrite=True) v.gsflow_hruparams(input=basins_inbasin, elevation=DEM, output=HRUs, slope=slope, aspect=aspect, overwrite=True) # GSFLOW gravity reservoirs v.gsflow_gravres(hru_input=HRUs, grid_input=MODFLOW_grid, output=gravity_reservoirs, overwrite=True)
* chi? * remember, these are meant to work ASSUMING STREAM POWER --> and therefore probably assuming bedrock, though all quite fuzzy in stream-power land anyway. """ # Full set of commands: elevation = 'srtm3' #slope = 'srtm.slope' #streams = 'srtm.stream # or THRESH if not STREAMS -- in km**2 thresh = 10 # 1 km2 = minimum catchment size # Made to work on a projected coordinate system PROJECTED! reg = region.Region() """ # Slope first, easy r.slope_aspect(elevation=elevation, slope='tmp', format='percent', overwrite=True) r.mapcalc('slope = tmp/100.', overwrite=True) # Assuming you work in meters. ASSUMING! # Have to include output name or write to a temporary file, FOR ALL! r.mapcalc('cellArea_meters2 = '+str(reg.nsres)+' * '+str(reg.ewres), overwrite=True) r.mapcalc("cellArea_km2 = cellArea_meters2 / 10^6", overwrite=True) # Works with MFD too! # Not really. Drainage from one catchment goes to multiple basins r.watershed(elevation=elevation, flow='cellArea_km2', accumulation='drainageArea_km2', drainage='drainageDirection', stream='streams_tmp', threshold=thresh, flags='s', overwrite=True) # Remove areas of negative (offmap) accumulation r.mapcalc('drainageArea_km2 = drainageArea_km2 * (drainageArea_km2 > 0)', overwrite=True) r.null(map='drainageArea_km2', setnull=0)
# or THRESH if not STREAMS -- in km**2 thresh = 0.2 # 10 km2 = minimum catchment size thresh = 10000 # m2 # Made to work on a projected coordinate system PROJECTED! reg = region.Region() ############## # BEFOREHAND # ############## # These also will generate inputs: code to run beforehand # Slope first, easy print "Computing slope with r.slope.aspect. Slope in unitless decimal values." r.slope_aspect(elevation=elevation, slope='tmp', format='percent', overwrite=True) r.mapcalc('slope = tmp/100.', overwrite=True) # Assuming you work in meters. ASSUMING! # Have to include output name or write to a temporary file, FOR ALL! r.mapcalc('cellArea_meters2 = ' + str(reg.nsres) + ' * ' + str(reg.ewres), overwrite=True) r.mapcalc("cellArea_km2 = cellArea_meters2 / 10^6", overwrite=True) print "Running r.watershed" r.watershed(elevation=elevation, flow='cellArea_meters2', accumulation='drainageArea_m2', drainage='drainageDirection', stream='streams',
from mower import GrassSession DEM = "/home/mperry/projects/shortcreek/dem/dem.img" with GrassSession(DEM) as gs: from grass.pygrass.modules.shortcuts import raster # Import/Link to External GDAL data raster.external(input=DEM, output="dem") # Perform calculations raster.mapcalc(expression="demft=dem*3.28084") raster.slope_aspect(elevation="demft", slope="slope", aspect="aspect") # Export from GRASS to GDAL from grass.pygrass.gis import Mapset m = Mapset() for r in m.glist('rast'): if r == "dem": # don't save the original continue raster.out_gdal(r, format="GTiff", output="/tmp/{}.tif".format(r), overwrite=True)
def slopestats(): slopemap = Rast(maps['elevation'].name + '.slope') r.slope_aspect(elevation=maps['elevation'].name, slope=slopemap.name, format='percent') print('\n \n Statistics for slope <%s> (slope in %%): '%(slopemap.name)) rsoillossstats(soilloss=slopemap.name, map=parcelmap.name, parcelnumcol='id')
from mower import GrassSession DEM = "/home/mperry/projects/shortcreek/dem/dem.img" with GrassSession(DEM) as gs: from grass.pygrass.modules.shortcuts import raster # Import/Link to External GDAL data raster.external(input=DEM, output="dem") # Perform calculations raster.mapcalc(expression="demft=dem*3.28084") raster.slope_aspect(elevation="demft", slope="slope", aspect="aspect") # Export from GRASS to GDAL from grass.pygrass.gis import Mapset m = Mapset() for r in m.glist('rast'): if r == "dem": # don't save the original continue raster.out_gdal(r, format="GTiff", output="/tmp/{}.tif".format(r), overwrite=True)