def __init__(self, epsg='5514'):
###########
self.file_type = None
self.grass_layer_types = {}
gisdb = os.path.join(tempfile.gettempdir(), 'grassdata')
if not os.path.isdir(gisdb):
os.mkdir(gisdb)
# location/mapset: use random names for batch jobs
string_length = 16
location = binascii.hexlify(os.urandom(string_length))
mapset = 'PERMANENT'
location_path = os.path.join(gisdb, location)
temp_dir = gisdb
# Create new location
# GRASS session must be initialized first
gsetup.init(os.environ['GISBASE'], gisdb, location, mapset)
try:
gscript.create_location(gisdb, location, epsg, overwrite=True)
except ScriptError as e:
raise ErosionError('{}'.format(e))
# Be quiet, print only error messages
os.environ['GRASS_VERBOSE'] = '0'
def worker_sun(cpu, julian_seed, step, demr, ow):
mtemp = 'temp' + str(cpu).zfill(2)
gsetup.init(gisbase, gisdbase, location, mtemp)
set_region(bregion, C)
# Input Maps
if (demr == 'dem'):
elevdem = dem + '@PERMANENT'
horr = demhor
else:
elevdem = can + '@PERMANENT'
horr = canhor
# Run r.sun for each week of the year 366
for doy in range(julian_seed, 366, step): # 366 normal max day of year
day = str(doy).zfill(3)
linke = linke_interp(doy, linke_array)
# Output maps
beam = P + demr + day + 'beam'
diff = P + demr + day + 'diff'
refl = P + demr + day + 'refl'
dur = P + demr + day + 'dur'
#glob = P+demr+day+'glob'
grass.run_command("r.sun", flags="s", elevin=elevdem, albedo=albedo, \
horizonstep=hstep, \
beam_rad=beam, insol_time=dur, \
diff_rad=diff, refl_rad=refl, \
day=doy, step=timestep, \
lin=linke, overwrite=ow)
def __init__(self):
# create temp GRASS location
import tempfile
import binascii
import grass.script as gs
from grass.script import setup as gsetup
# path to temp location
gisdb = os.path.join(tempfile.gettempdir(), 'grassdata')
if not os.path.isdir(gisdb):
os.mkdir(gisdb)
# location: use random names for batch jobs
string_length = 16
location = binascii.hexlify(os.urandom(string_length)).decode("utf-8")
# initialize GRASS session
gsetup.init(os.environ['GISBASE'], gisdb, location, 'PERMANENT')
# create location
try:
gs.create_location(gisdb, location, epsg='5514', overwrite=True)
except SmoderpError as e:
raise SmoderpError('{}'.format(e))
# test GRASS env varible
if not os.getenv('GISRC'):
raise SmoderpError('GRASS not found.')
super().__init__()
def function(pa):
if pa not in pa_list_done:
mymapset = 'm'+str(pa)
spn00= str(GRASSDBASE)+'/'+str(MYLOC)+'/PERMANENT/DEFAULT_WIND'
spn0x= str(GRASSDBASE)+'/'+str(MYLOC)+'/'+str(mymapset)
spn01= str(GRASSDBASE)+'/'+str(MYLOC)+'/'+str(mymapset)+'/WIND'
spn= str(GRASSDBASE)+'/'+str(MYLOC)+'/'+str(mymapset)+'/SEARCH_PATH'
comm0 = 'mkdir '+spn0x
comm = 'cp '+spn00+' '+spn01
os.system(comm0)
os.system(comm)
wb = open(spn,'a')
wb.write('PERMANENT')
wb.write('\n')
wb.write('user1')
wb.write('\n')
wb.write(str(mymapset))
wb.write('\n')
wb.close()
gsetup.init(GISBASE, GRASSDBASE, MYLOC, mymapset)
pa0 = 'v0_'+pa
opt1 = 'NAME=\''+pa+'\''
grass.run_command('v.extract', input=source, out=pa0, where=opt1,overwrite=True)
grass.run_command('g.region',vect=pa0)
pa5 = pa+'.tif'
grass.run_command('r.mask', vector=pa0)
opt2 = pa+'= const'
grass.run_command('r.mapcalc',expression=opt2,overwrite=True)
grass.run_command('r.out.gdal',input=pa,out=pa5)
print "Done:"+pa
comm1 = 'rm -rf '+spn0x
os.system(comm1)
def initialize_GRASS(self):
if self.location:
if not self.quiet:
print "Using GRASS location", self.location
else:
sys.exit("Must define a GRASS GIS location.")
# Implicitly
os.environ['GISBASE'] = self.gisbase
gisdbase = os.path.join(os.environ['HOME'], self.grassdata_dir)
sys.path.append(os.path.join(os.environ['GISBASE'], "etc", "python"))
import grass.script as gr
import grass.script.setup as gsetup
gsetup.init(self.gisbase, gisdbase, self.location, self.mapset)
from grass.script import array as garray
self.gr = gr
self.garray = garray
if self.north is None and self.south is None and self.west is None and self.east is None:
pass
elif self.north is None or self.south is None or self.west is None or self.east is None:
sys.exit('Incomplete description of edge values')
else:
self.gr.run_command('g.region', n=self.north, s=self.south, w=self.west, e=self.east)
# Then apply the desired resolution.
# This won't be *quite* a square grid, but will be close.
if self.dx and self.dy:
self.gr.run_command('g.region', ewres=self.dx, nsres=self.dy)
else:
if not self.quiet:
print "dx and dy not both defined: not updating grid resolution."
self.gr.run_command('g.region', save='IceFlowRegion', overwrite=True) # Save it
def clip_and_union(la, lb, cell, work, ref, proc, output):
# Start GRASS GIS Session
grsbase = run_grass(work, location="proc_" + str(proc), srs=ref)
import grass.script.setup as gsetup
gsetup.init(grsbase, work, "proc_" + str(proc), 'PERMANENT')
# Import GRASS GIS modules
from gasp.to.shp.grs import shp_to_grs
from gasp.to.shp.grs import grs_to_shp
# Add data to GRASS
a = shp_to_grs(la, get_filename(la), asCMD=True)
b = shp_to_grs(lb, get_filename(lb), asCMD=True)
c = shp_to_grs(cell, get_filename(cell), asCMD=True)
# Clip
a_clip = clip(a, c, "{}_clip".format(a), api_gis="grass_cmd")
b_clip = clip(b, c, "{}_clip".format(b), api_gis="grass_cmd")
# Union
u_shp = union(a_clip,
b_clip,
"un_{}".format(c),
api_gis="grass_cmd")
# Export
o = grs_to_shp(u_shp, output, "area")
def start_grass_session(crs=None):
"""Starts a GRASS session, provided it has been setup before (see
setup_grass()). This will only search for GRASS projects located in
Grass.path, which by default is a subdirectory of the provided data
directory!
:param crs: EPSG code the GRASS project was set up in (e.g.
'32629'). This parameter is used to identify automatically generated
GRASS projects that contain the EPSG code in their name. [str]
:returns: GRASS session
"""
## If no crs is provided, look for a GRASS project starting with
## 'GRASS_db_' in the GRASS location (Grass.path). By design there
## should be only one project.
if crs is None:
res = [x for x in os.listdir(Grass.path) if re.search('GRASS_db_', x)]
project_name = res[0]
else:
location = os.path.join(Grass.path, f'GRASS_db_{crs}')
if not os.path.isdir(location):
raise ImportError(
f"A GRASS Location with the name 'GRASS_db_{crs}' has not "
f"been set up yet.")
else:
project_name = f'GRASS_db_{crs}'
gisbase = get_grass_gisbase()
gisdb = Grass.path
mapset = 'PERMANENT'
gsetup.init(gisbase, gisdb, project_name, mapset)
print(f"~~ Current GRASS GIS environment: \n {gscript.gisenv()}")
def setup_wrkspace(gisdbase, ccr_grassrc, geo_file):
"""Setup GRASS workspace and modify windows path for GRASS GDAL"""
lm_util.gprint("Creating GRASS workspace")
gisbase = cc_env.gisbase
location = "gcwd"
mapset = "PERMANENT"
os.environ['GISRC'] = ccr_grassrc
os.environ['LD_LIBRARY_PATH'] = os.path.join(gisbase, "lib")
os.environ['GRASS_SH'] = os.path.join(gisbase, "msys", "bin", "sh.exe")
try:
grass.create_location(gisdbase, location, filename=geo_file)
except:
cc_util.gdal_fail_check()
arcpy.AddWarning("GRASS ERROR. Try rebooting and restarting ArcGIS.")
arcpy.AddWarning("If that doesn't work you can try using ")
arcpy.AddWarning("the 'CC Run Script.py' python script in the ")
arcpy.AddWarning("demo directory where the Linkage Mapper toolbox")
arcpy.AddWarning("is installed instead of ArcGIS to call the tool")
arcpy.AddWarning("(see user guide).")
raise Exception("GRASS ERROR: Cannot create workspace.")
gsetup.init(gisbase, gisdbase, location, mapset)
run_grass_cmd("g.gisenv", set="OVERWRITE=1")
os.environ['GRASS_VERBOSE'] = "0" # Only errors and warnings are printed
def worker_sun(cpu,julian_seed,step,demr,ow):
mtemp = 'temp'+str(cpu).zfill(2)
gsetup.init(gisbase, gisdbase, location, mtemp)
set_region(bregion,C)
# Input Maps
if(demr == 'dem'):
elevdem = dem+'@PERMANENT'
horr = demhor
else:
elevdem = can+'@PERMANENT'
horr = canhor
# Run r.sun for each week of the year 366
for doy in range(julian_seed,366,step): # 366 normal max day of year
day = str(doy).zfill(3)
linke = linke_interp(doy,linke_array)
# Output maps
beam = P+demr+day+'beam'
diff = P+demr+day+'diff'
refl = P+demr+day+'refl'
dur = P+demr+day+'dur'
#glob = P+demr+day+'glob'
grass.run_command("r.sun", flags="s", elevin=elevdem, albedo=albedo, \
horizonstep=hstep, \
beam_rad=beam, insol_time=dur, \
diff_rad=diff, refl_rad=refl, \
day=doy, step=timestep, \
lin=linke, overwrite=ow)
def grass_setup():
"""
this function initializes the GRASS session and creates the mapset with the user-specified variables
"""
user_data()
location_name = GrassData.location_name
crs = GrassData.crs
grassbin = GRASSBIN_import()
if grassbin == "grass7bin_win":
print("You're using Windows, this module most likely will not work properly, please use a linux-based OS!!!")
os.environ['GRASSBIN'] = grassbin
gisbase = get_grass_gisbase()
os.environ['GISBASE'] = gisbase
sys.path.append(os.path.join(os.environ['GISBASE'], 'bin'))
sys.path.append(os.path.join(os.environ['GISBASE'], 'lib'))
sys.path.append(os.path.join(os.environ['GISBASE'], 'scripts'))
sys.path.append(os.path.join(os.environ['GISBASE'], 'etc', 'python'))
# set folder to proj_lib:
os.environ['PROJ_LIB'] = '/usr/share/proj'
gisdb = Paths.grass_path
mapset = "PERMANENT"
##################################################################################
# open a GRASS session and create the mapset if it does not yet exist
with Session(gisdb=gisdb,
location=GrassData.location_name,
create_opts='EPSG:' + crs):
pass
##################################################################################
# launch session
gsetup.init(gisbase, gisdb, location_name, mapset)
print(f"Current GRASS GIS 7 environment: {gscript.gisenv()}")
def matrix_od(origins, destinations, networkShp, speedLimitCol, onewayCol,
grsWorkspace, grsLocation, outputShp):
"""
Produce matrix OD using GRASS GIS
"""
from glass.pys.oss import fprop
from glass.g.wenv.grs import run_grass
# Open an GRASS GIS Session
gbase = run_grass(grsWorkspace,
grassBIN="grass76",
location=grsLocation,
srs=networkShp)
import grass.script as grass
import grass.script.setup as gsetup
gsetup.init(gbase, grsWorkspace, grsLocation, 'PERMANENT')
# Import GRASS GIS Module
from glass.g.it.shp import shp_to_grs, grs_to_shp
# Add Data to GRASS GIS
rdvMain = shp_to_grs(networkShp, fprop(networkShp, 'fn', forceLower=True))
"""Get matrix distance:"""
MATRIX_OD = prod_matrix(origins, destinations, rdvMain, speedLimitCol,
onewayCol)
return grs_to_shp(MATRIX_OD, outputShp, "line", lyrN=3)
def hexagrid(gisbase,gisdb, mapset, location="cea",radius=15000):
import grass
reload(grass)
import grass.script as gscript
import grass.script.setup as gsetup
gsetup.init(gisbase,
gisdb, location, mapset)
radius=int(radius)
if radius==0:
radius = 10000
radius2 = radius*2
gscript.run_command('v.proj',location='ll',input='sample',output='sample',overwrite=True,quiet=True)
gscript.run_command('g.region',vect='sample',quiet=True)
gscript.run_command('g.region',n='n+%d' % radius2 ,e='e+%d' % radius2, \
w='w-%d' % radius2,s='s-%d' % radius2,quiet=True)
gscript.run_command('v.mkgrid',flags='h',map='grid',box=(radius,radius),overwrite=True,quiet=True)
gscript.run_command('v.out.ogr',input='sample',output='sample_ease',overwrite=True,quiet=True)
gscript.run_command('v.out.ogr',input='grid',output='grid_ease',overwrite=True,quiet=True)
gscript.run_command('v.db.addcolumn',map='sample',column='cellid integer',quiet=True)
gscript.run_command('v.what.vect',map='sample',column='cellid',query_map='grid',query_column='cat',quiet=True)
result = gscript.read_command('db.select',sql='select * from sample')
with open('result.csv','w') as t:
t.write(result)
t.close()
s = gscript.read_command('db.select', flags='c', \
sql='select cellid from sample where cellid is not null')
a = set(s.split('\n'))
a.discard('')
b = str(','.join(str(e) for e in a))
gscript.run_command('v.extract',input='grid',output='subgrid', where="cat in (%s)" % b,overwrite=True,quiet=True)
gscript.run_command('v.out.ogr',input='subgrid',output='subgrid_ease',overwrite=True,quiet=True,format="ESRI_Shapefile")
def working_mapset(gisdb_path,location_name,mapset_name):
"""Launch GRASS GIS working session in the mapset"""
if os.path.exists(os.path.join(gisdb_path,location_name,mapset_name)):
gsetup.init(os.environ['GISBASE'], gisdb_path,location_name,mapset_name)
print "You are now working in mapset '%s'"%mapset_name
else:
print "'%s' mapset doesn't exists in '%s'"%(mapset_name, gisdb_path)
def fsegm(pa):
### mp.current_process().cnt += 1
current = multiprocessing.current_process()
mn = current._identity[0]
print 'running:', mn
GISBASE = os.environ['GISBASE'] = "/home/majavie/hierba_hanks/grass-7.1.svn"
GRASSDBASE = "/home/majavie/hanksgrass7"
MYLOC = "global_MW"
mapset = 'm'
sys.path.append(os.path.join(os.environ['GISBASE'], "etc", "python"))
import grass.script as grass
import grass.script.setup as gsetup
gsetup.init(GISBASE, GRASSDBASE, MYLOC, mapset)
mapset2 = 'm'+str(mn)#ehabitat'
os.system ('rm -rf /home/majavie/hanksgrass7/global_MW/'+mapset2)
grass.run_command('g.mapset',mapset=mapset2,location='global_MW',gisdbase='/home/majavie/hanksgrass7',flags='c')
gsetup.init(GISBASE, GRASSDBASE, MYLOC, mapset2)
print mapset2, grass.gisenv()
print pa
grass.run_command('g.mapsets',mapset='ehabitat,rasterized_parks',operation='add')
grass. message ("Deleting tmp layers")
os.system ('rm -rf /home/majavie/hanksgrass7/global_MW/'+mapset2)
gc.collect()
def matrix_od(origins, destinations, networkShp, speedLimitCol, onewayCol,
grsWorkspace, grsLocation, outputShp):
"""
Produce matrix OD using GRASS GIS
"""
from gasp.oss import get_filename
from gasp.session import run_grass
# Open an GRASS GIS Session
gbase = run_grass(grsWorkspace,
grassBIN="grass74",
location=grsLocation,
srs=networkShp)
import grass.script as grass
import grass.script.setup as gsetup
gsetup.init(gbase, grsWorkspace, grsLocation, 'PERMANENT')
# Import GRASS GIS Module
from gasp.to.shp.grs import shp_to_grs
# Add Data to GRASS GIS
rdvMain = shp_to_grs(networkShp, get_filename(networkShp, forceLower=True))
"""Get matrix distance:"""
MATRIX_OD = prod_matrix(origins, destinations, rdvMain, speedLimitCol,
onewayCol)
return grass_converter(MATRIX_OD, outputShp, geom_type="line", lyrN=3)
def gsetup(self):
path = os.path.join(self.gisbase, 'etc', 'python')
sys.path.append(path)
os.environ['PYTHONPATH'] = ':'.join(sys.path)
import grass.script.setup as gsetup
gsetup.init(self.gisbase, self.gisdb, self.location, self.mapset)
def setup_wrkspace(gisdbase, ccr_grassrc, geo_file):
"""Configure GRASS workspace."""
lm_util.gprint("Creating GRASS workspace")
gisbase = cc_env.gisbase
location = "gcwd"
mapset = "PERMANENT"
os.environ['GISRC'] = ccr_grassrc
os.environ['LD_LIBRARY_PATH'] = os.path.join(gisbase, "lib")
os.environ['GRASS_SH'] = os.path.join(gisbase, "msys", "bin", "sh.exe")
try:
grass.create_location(gisdbase, location, filename=geo_file)
except grass.ScriptError:
warn_msg = ("Cannot create GRASS workspace.\n"
"Try rebooting and restarting ArcGIS. If that doesn't\n"
"work you can try using the 'cc_demo.py' python script\n"
"in the demo/demo_scripts/ directory where the Linkage\n"
"Mapper toolbox is installed instead of ArcGIS to call\n"
"the tool (see user guide).")
raise Exception(warn_msg)
gsetup.init(gisbase, gisdbase, location, mapset)
run_grass_cmd("g.gisenv", set="OVERWRITE=1")
os.environ['GRASS_VERBOSE'] = "0" # Only errors and warnings are printed
def gsetup(self):
path = os.path.join(self.gisbase, 'etc', 'python')
sys.path.append(path)
os.environ['PYTHONPATH'] = ':'.join(sys.path)
import grass.script.setup as gsetup
gsetup.init(self.gisbase, self.gisdb, self.location, self.mapset)
def setup_wrkspace(gisdbase, ccr_grassrc, geo_file):
"""Setup GRASS workspace and modify windows path for GRASS GDAL"""
lm_util.gprint("Creating GRASS workspace")
gisbase = cc_env.gisbase
location = "gcwd"
mapset = "PERMANENT"
os.environ['GISRC'] = ccr_grassrc
os.environ['LD_LIBRARY_PATH'] = os.path.join(gisbase, "lib")
os.environ['GRASS_SH'] = os.path.join(gisbase, "msys", "bin", "sh.exe")
try:
grass.create_location(gisdbase, location, filename=geo_file)
except:
cc_util.gdal_fail_check()
arcpy.AddWarning("GRASS ERROR. Try rebooting and restarting ArcGIS.")
arcpy.AddWarning("If that doesn't work you can try using ")
arcpy.AddWarning("the 'CC Run Script.py' python script in the ")
arcpy.AddWarning("demo directory where the Linkage Mapper toolbox")
arcpy.AddWarning("is installed instead of ArcGIS to call the tool")
arcpy.AddWarning("(see user guide).")
raise Exception("GRASS ERROR: Cannot create workspace.")
gsetup.init(gisbase, gisdbase, location, mapset)
run_grass_cmd("g.gisenv", set="OVERWRITE=1")
os.environ['GRASS_VERBOSE'] = "0" # Only errors and warnings are printed
def Cross(gisbase,gisdb, mapset, location="cea", vector_name="grid", point_name="sample", group=None):
import grass
reload(grass)
import grass.script as gscript
import grass.script.setup as gsetup
gsetup.init(gisbase,
gisdb, location, mapset)
suffix=""
if location=="cea":
suffix="_ease"
gscript.run_command('v.out.ogr',input=point_name,output=point_name+suffix,overwrite=True,quiet=True)
gscript.run_command('v.out.ogr',input=vector_name,output=vector_name+suffix,overwrite=True,quiet=True,flags='m')
gscript.run_command('v.db.addcolumn',map='sample',column='cellid integer',quiet=True)
gscript.run_command('v.db.addcolumn',map='sample',column=group+ " VARCHAR(10)",quiet=True)
gscript.run_command('v.what.vect',map='sample',column='cellid',query_map=vector_name,query_column='cat',quiet=True)
if group:
gscript.run_command('v.what.vect',map='sample',column=group,query_map=vector_name,query_column=group,quiet=True)
result = gscript.read_command('db.select',sql='select * from '+point_name)
with open('result.csv','w') as t:
t.write(result)
t.close()
s = gscript.read_command('db.select', flags='c', \
sql='select cellid from sample where cellid is not null')
a = set(s.split('\n'))
a.discard('')
b = str(','.join(str(e) for e in a))
subname='sub'+vector_name
gscript.run_command('v.extract',input=vector_name,output=subname, where="cat in (%s)" % b,overwrite=True,quiet=True)
gscript.run_command('v.out.ogr',input=subname,output=subname+suffix,overwrite=True,quiet=True,flags="m",format="ESRI_Shapefile")
def preprocessing(localpath,mapset,canr,ow):
gsetup.init(gisbase, gisdbase, location, mapset)
set_region(bregion,C)
# Canopy Raster - 2nd test
boocan = raster_exists(canr,mapset)
if(boocan == False):
str_error = "Canopy raster does not exist. Please run ssr_lidar.py first"
return str_error
print 'canopy rester exists: ',boocan
# Regrid from Input Raster to Target Cell size
if(demsource != dem):
grass.run_command("r.resample",input=demsource,output=dem,overwrite=ow)
if(canr != can):
grass.run_command("r.resample",input=canr,output=can,overwrite=ow)
# Slope and Aspect
grass.run_command("r.slope.aspect", elevation=dem, slope=sloped, \
aspect=aspectd, prec="float", zfactor=1, overwrite=ow)
grass.run_command("r.slope.aspect", elevation=can, slope=slopec, \
aspect=aspectc, prec="float", zfactor=1, overwrite=ow)
# Vegetation height
grass.mapcalc("$vegheight = $can - $dem", overwrite = ow, \
vegheight = vegheight, can = can, dem = dem)
# Albedo
albedofile = localpath+'albedo_recode.txt'
grass.run_command("r.recode",flags="a",input=vegheight,output=albedo,\
rules=albedofile, overwrite=ow)
# return to main
str_result = 'Preprocessing: completed successfully using canopy raster: ',canr
return str_result
def run_viewshed_by_cpu(tid, obs, dem, output,
vis_basename='vis', maxdst=None, obselevation=None):
# Create GRASS GIS location
loc_name = 'loc_' + str(tid)
gbase = run_grass(output, location=loc_name, srs=dem)
# Start GRASS GIS Session
import grass.script as grass
import grass.script.setup as gsetup
gsetup.init(gbase, output, loc_name, 'PERMANENT')
from glass.g.it.rst import rst_to_grs, grs_to_rst
from glass.g.rst.surf import grs_viewshed
# Send DEM to GRASS GIS
grs_dem = rst_to_grs(dem, 'grs_dem', as_cmd=True)
# Produce Viewshed for each point in obs
for idx, row in obs.iterrows():
vrst = grs_viewshed(
grs_dem, (row.geometry.x, row.geometry.y),
'{}_{}'.format(vis_basename, str(row[obs_id])),
max_dist=maxdst, obs_elv=obselevation
)
frst = grs_to_rst(vrst, os.path.join(output, vrst + '.tif'))
def MakeHexagrid(gisbase,
gisdb,
mapset,
location="cea",
radius=15000,
point_name="sample",
point_loc="ll"):
import grass
reload(grass)
import grass.script as gscript
import grass.script.setup as gsetup
gsetup.init(gisbase, gisdb, location, mapset)
radius = int(radius)
if radius == 0:
radius = 10000
radius2 = radius * 2
gscript.run_command('v.proj',
location=point_loc,
input=point_name,
output='sample',
overwrite=True,
quiet=True)
gscript.run_command('g.region', vect='sample', quiet=True)
gscript.run_command('g.region',n='n+%d' % radius2 ,e='e+%d' % radius2, \
w='w-%d' % radius2,s='s-%d' % radius2,quiet=True)
gscript.run_command('v.mkgrid',
flags='h',
map='grid',
box=(radius, radius),
overwrite=True,
quiet=True)
def initialize_GRASS(self):
if self.location:
if not self.quiet:
print "Using GRASS location", self.location
else:
sys.exit("Must define a GRASS GIS location.")
# Implicitly
os.environ['GISBASE'] = self.gisbase
gisdbase = os.path.join(os.environ['HOME'], self.grassdata_dir)
sys.path.append(os.path.join(os.environ['GISBASE'], "etc", "python"))
import grass.script as gr
import grass.script.setup as gsetup
gsetup.init(self.gisbase, gisdbase, self.location, self.mapset)
from grass.script import array as garray
self.gr = gr
self.garray = garray
if self.north is None and self.south is None and self.west is None and self.east is None:
pass
elif self.north is None or self.south is None or self.west is None or self.east is None:
sys.exit('Incomplete description of edge values')
else:
self.gr.run_command('g.region', n=self.north, s=self.south, w=self.west, e=self.east)
# Then apply the desired resolution.
# This won't be *quite* a square grid, but will be close.
if self.dx and self.dy:
self.gr.run_command('g.region', ewres=self.dx, nsres=self.dy)
else:
if not self.quiet:
print "dx and dy not both defined: not updating grid resolution."
self.gr.run_command('g.region', save='IceFlowRegion', overwrite=True) # Save it
def shp_to_shp(inshp, outshp, gisApi='ogr', supportForSpatialLite=None):
"""
Convert a vectorial file to another with other file format
API's Available:
* ogr;
* grass;
When using gisApi='ogr' - Set supportForSpatialLite to True if outShp is
a sqlite db and if you want SpatialLite support for that database.
"""
if gisApi == 'ogr':
from glass.pys import execmd
from glass.g.prop import drv_name
out_driver = drv_name(outshp)
if out_driver == 'SQLite' and supportForSpatialLite:
splite = ' -dsco "SPATIALITE=YES"'
else:
splite = ''
cmd = 'ogr2ogr -f "{drv}" {out} {_in}{lite}'.format(drv=out_driver,
out=outshp,
_in=inshp,
lite=splite)
# Run command
cmdout = execmd(cmd)
elif gisApi == 'grass':
# TODO identify input geometry type
import os
from glass.pys.oss import fprop
from glass.g.wenv.grs import run_grass
from glass.g.prop.prj import get_epsg
# Start GRASS GIS Session
ws = os.path.dirname(outshp)
loc = f'loc_{fprop(outshp, "fn")}'
epsg = get_epsg(inshp)
gbase = run_grass(ws, location=loc, srs=epsg)
import grass.script.setup as gsetup
gsetup.init(gbase, ws, loc, 'PERMANENT')
from glass.g.it.shp import grs_to_shp, shp_to_grs
gshp = shp_to_grs(inshp, fprop(inshp, 'fn'))
grs_to_shp(gshp, outshp, 'area')
else:
raise ValueError('Sorry, API {} is not available'.format(gisApi))
return outshp
def clip(inFeat, clipFeat, outFeat, api_gis="grass", clip_by_region=None):
"""
Clip Analysis
api_gis Options:
* grass
* pygrass
* ogr2ogr
"""
from glass.pys.oss import fprop
if api_gis == "pygrass" or api_gis == "grass":
import os
from glass.g.wenv.grs import run_grass
from glass.g.prop.prj import get_epsg
epsg = get_epsg(inFeat)
work = os.path.dirname(outFeat)
refname = fprop(outFeat, 'fn')
loc = f"loc_{refname}"
grsbase = run_grass(work, location=loc, srs=epsg)
import grass.script.setup as gsetup
gsetup.init(grsbase, work, loc, 'PERMANENT')
from glass.g.it.shp import shp_to_grs, grs_to_shp
from glass.g.prop.feat import feat_count
shp = shp_to_grs(inFeat, fprop(inFeat, 'fn'))
clp = shp_to_grs(clipFeat, fprop(clipFeat, 'fn'))
# Clip
rslt = grsclip(shp,
clp,
refname,
cmd=True if api_gis == "grass" else None,
clip_by_region=clip_by_region)
# Export
grs_to_shp(rslt, outFeat, 'area')
elif api_gis == 'ogr2ogr':
from glass.pys import execmd
from glass.g.prop import drv_name
rcmd = execmd(
("ogr2ogr -f \"{}\" {} {} -clipsrc {} -clipsrclayer {}").format(
drv_name(outFeat), outFeat, inFeat, clipFeat,
fprop(clipFeat, 'fn')))
else:
raise ValueError("{} is not available!".format(api_gis))
return outFeat
def working_mapset(gisdb_path, location_name, mapset_name):
## Launch GRASS GIS working session in the mapset
if os.path.exists(os.path.join(gisdb_path, location_name, mapset_name)):
gsetup.init(os.environ['GISBASE'], gisdb_path, location_name,
mapset_name)
return "You are now working in mapset '%s/%s'" % (location_name,
mapset_name)
else:
return "'%s' mapset doesn't exists in '%s'" % (mapset_name, gisdb_path)
def addVec(gisbase,gisdb, mapset, pathPythonScript, dirName='terr-ecoregions-TNC/' ,fileName='tnc_terr_ecoregions',location="ll", name="Biome"):
import grass
reload(grass)
import grass.script as gscript
import grass.script.setup as gsetup
gsetup.init(gisbase,gisdb, location, mapset)
wdIN=os.path.dirname(os.path.abspath(pathPythonScript))
#temp=os.path.join(wdIN,addon,dirName)
gscript.run_command('v.in.ogr',input=dirName,layer=fileName,output=name, overwrite=True)
def remove_temp(cores): # OUTSIDE
# setup is in the target mapset, not temp mapsets
gsetup.init(gisbase, gisdbase, location, 'PERMANENT')
# Delete the temp mapset
for count in range(0,cores):
mapset_temp = 'temp'+str(count).zfill(2)
grass.run_command("g.mapsets", removemapset=mapset_temp)
temp_path = gisdbase+'/'+location+'/'+mapset_temp
shutil.rmtree(temp_path)
def init_finish(queue):
gs.set_capture_stderr(True)
location = "test"
gs.core._create_location_xy( # pylint: disable=protected-access
tmp_path, location)
grass_setup.init(tmp_path / location)
gs.run_command("g.region", flags="p")
queue.put(os.environ["GISRC"])
grass_setup.finish()
def test_init_finish_global_functions(tmp_path):
"""Check that init and finish global functions work"""
location = "test"
gs.core._create_location_xy(tmp_path, location) # pylint: disable=protected-access
grass_setup.init(tmp_path / location)
gs.run_command("g.region", flags="p")
session_file = os.environ["GISRC"]
grass_setup.finish()
assert not os.path.exists(session_file)
def init_grass(path, grasslib):
"""
Initialisation of Grass GIS in lambert 93.
in :
path : directory where create grassdata directory
grasslib : install directory of Grass GIS
"""
global gscript
# Grass folder Initialisation
if not os.path.exists(os.path.join(path, "grassdata")):
os.mkdir(os.path.join(path, "grassdata"))
path_grassdata = os.path.join(path, "grassdata")
# Init Grass environment
gisbase = os.environ['GISBASE'] = grasslib
gisdb = os.path.join(path_grassdata)
sys.path.append(os.path.join(os.environ["GISBASE"], "etc", "python"))
os.environ["GISBASE"] = gisbase
# Overwrite and verbose parameters
os.environ["GRASS_OVERWRITE"] = "1"
os.environ['GRASS_VERBOSE'] = '-1'
# Grass functions import
import grass.script.setup as gsetup
import grass.script as gscript
# Init Grass
gsetup.init(gisbase, gisdb)
# Delete existing location
if os.path.exists(os.path.join(gisdb, "demolocation")):
shutil.rmtree(os.path.join(gisdb, "demolocation"))
# Create the location in Lambert 93
gscript.run_command("g.proj",
flags="c",
epsg="2154",
location="demolocation")
# Create datas mapset
if not os.path.exists(os.path.join(gisdb, "/demolocation/datas")):
try:
gscript.start_command("g.mapset",
flags="c",
mapset="datas",
location="demolocation",
dbase=gisdb)
except:
raise Exception("Folder '%s' does not own to current user") % (
gisdb)
def create_temp(cores,bregion,C,lf): # OUTSIDE
gsetup.init(gisbase, gisdbase, location, 'PERMANENT')
for count in range(0,cores,1):
temp = 'temp'+str(count).zfill(2)
temp_path = gisdbase+os.sep+location+os.sep+temp
if(os.path.exists(temp_path) == False):
grass.run_command("g.mapset",flags="c", mapset=temp, quiet=1)
set_region(bregion,C)
printout(temp+" mapset created.",lf)
else:
printout(temp+" mapset already exists. skipping...",lf)
def init_grass():
"""!Intialize GRASS session"""
gisdbase = os.path.join(tempfile.gettempdir())
location = "test_vfk_%d" % os.getpid()
import grass.script.setup as gsetup
gsetup.init(gisbase,
gisdbase, location)
grass.create_location(gisdbase, location, epsg = 2065, overwrite=True)
def connectionGrass(gisbase,
gisdb,
location="",
mapset="PERMANENT",
projection=2154):
if location == "":
gsetup.init(gisbase, gisdb)
else:
if not os.path.exists(gisdb + os.sep + location):
grass.core.create_location(gisdb, location, projection)
gsetup.init(gisbase, gisdb, location, mapset)
return
def bash_matrix_od(origins, destinationShp, network, costCol, oneway, grsWork,
output):
"""
Produce matrix OD using GRASS GIS - BASH MODE
"""
from gasp.session import run_grass
from gasp.oss import get_filename
from gasp.oss.ops import create_folder
from gasp.mng.split import splitShp_by_range
from gasp.mng.gen import merge_feat
# SPLIT ORIGINS IN PARTS
originsFld = create_folder(os.path.join(grsWork, 'origins_parts'))
originsList = splitShp_by_range(origins, 100, originsFld)
# Open an GRASS GIS Session
gbase = run_grass(grsWork,
grassBIN="grass76",
location=grsLoc,
srs=network)
import grass.script as grass
import grass.script.setup as gsetup
RESULTS = []
R_FOLDER = create_folder(os.path.join(grsWork, 'res_parts'))
for e in range(len(originsList)):
gsetup.init(gbase, grsWork, "grs_loc_{}".format(e), 'PERMANENT')
from gasp.to.shp.grs import shp_to_grs, grs_to_shp
# Add Data to GRASS GIS
rdvMain = shp_to_grs(network, get_filename(network, forceLower=True))
# Produce Matrix
result_part = prod_matrix(originsList[e], destinationShp, rdvMain,
costCol, oneway)
# Export Result
shp = grs_to_shp(result_part,
os.path.join(R_FOLDER, result_part + '.shp'),
geom_type="line",
lyrN=3)
RESULTS.append(shp)
merge_feat(RESULTS, output, api='pandas')
return output
def union(lyrA, lyrB, outShp, api_gis="grass"):
"""
Calculates the geometric union of the overlayed polygon layers, i.e.
the intersection plus the symmetrical difference of layers A and B.
API's Available:
* saga;
* grass;
* pygrass;
"""
if api_gis == "saga":
from glass.pys import execmd
rcmd = execmd(
("saga_cmd shapes_polygons 17 -A {} -B {} -RESULT {} -SPLIT 1"
).format(lyrA, lyrB, outShp))
elif api_gis == "pygrass" or api_gis == "grass":
import os
from glass.g.wenv.grs import run_grass
from glass.pys.oss import fprop
from glass.g.prop.prj import get_epsg
ws = os.path.dirname(outShp)
refname = fprop(outShp)
loc = f"loc_{refname}"
gbase = run_grass(ws, location=loc, srs=get_epsg(lyrA))
import grass.script.setup as gs
gs.init(gbase, ws, loc, 'PERMANENT')
# Import data
from glass.g.it.shp import shp_to_grs, grs_to_shp
lyr_a = shp_to_grs(lyrA, fprop(lyrA, 'fn'), asCMD=True)
lyr_b = shp_to_grs(lyrB, fprop(lyrB, 'fn'), asCMD=True)
shpunion = grsunion(lyr_a,
lyr_b,
refname,
cmd=True if api_gis == "grass" else None)
# Export data
grs_to_shp(shpunion, outShp, "area")
else:
raise ValueError("{} is not available!".format(api_gis))
return outShp
def run_slope(tid, inrsts, outfolder, oname, percentage):
"""
Thread function
"""
iirsts = inrsts.mdt.tolist()
# Create GRASS GIS Location
loc_name = f'thread_{str(tid)}'
gbase = run_grass(
outfolder, location=loc_name, srs=iirsts[0]
)
# Start GRASS GIS Session
import grass.script as grass
import grass.script.setup as gsetup
gsetup.init(gbase, outfolder, loc_name, 'PERMANENT')
from glass.g.it.rst import rst_to_grs, grs_to_rst
from glass.g.rst.surf import slope
from glass.g.wenv.grs import rst_to_region
for rst in iirsts:
# Import data
mdt = rst_to_grs(rst, fprop(rst, 'fn'))
# Set region
rst_to_region(mdt)
# Get ID in name
mdt_id = re.search(r'\d+', mdt).group()
# Get slope
if percentage:
slope_perc = slope(
mdt, f"pp_{oname}_{mdt_id}",
data='percent'
)
slope_degr = slope(
mdt, f"{oname}_{mdt_id}", data='degrees'
)
# Export
if percentage:
grs_to_rst(slope_perc, os.path.join(
percentage, slope_degr + '.tif'
))
grs_to_rst(slope_degr, os.path.join(
outfolder, slope_degr + '.tif'
))
def _setupGrassScriptingEnvironment(self):
""" @brief Set up GRASS environment for using GRASS scripting API from
Python (e.g. grass.script)
"""
os.environ['GISBASE'] = self.grassConfig.gisbase
sys.path.append(os.path.join(self.grassConfig.gisbase, 'etc', 'python'))
import grass.script.setup as gsetup
gsetup.init(self.grassConfig.gisbase, \
self.grassConfig.dbase, self.grassConfig.location, \
self.grassConfig.mapset)
self.script = importlib.import_module('grass.script')
return self.script
def _setupGrassScriptingEnvironment(self):
""" @brief Set up GRASS environment for using GRASS scripting API from
Python (e.g. grass.script)
"""
os.environ['GISBASE'] = self.grass_config.gisbase
sys.path.append(os.path.join(self.grass_config.gisbase, 'etc', 'python'))
import grass.script.setup as gsetup
gsetup.init(self.grass_config.gisbase, \
self.grass_config.dbase, self.grass_config.location, \
self.grass_config.mapset)
self.g = importlib.import_module('grass.script')
return self.g
def init(path, location=None, mapset=None, grass_path=None):
"""
This function initiates a GRASS session and sets GRASS
environment variables.
:param str path: path to grass databases
:param str location: name of GRASS location
:param str mapset: name of mapset within location
"""
# Create a GRASS GIS session.
gsetup.init(path, location=location, mapset=mapset, grass_path=grass_path)
# Set GRASS env. variables
_set_notebook_defaults()
def copy_mapset(mapset_from,mapset_to,regfilter,overwrite,lf): # OUTSIDE
gsetup.init(gisbase, gisdbase, location, mapset_from)
#grass.run_command("g.mapset", mapset=mapset_from, quiet=1)
# list contents of temp mapset
raster_list = grass.list_pairs(type = 'rast')
# Switch to target mapset and copy rasters over
grass.run_command("g.mapset", mapset=mapset_to,quiet=0)
for rast in raster_list:
if(rast[1] != 'PERMANENT' and re.search(regfilter,rast[0])):
old = rast[0]+ '@' + rast[1]
new = rast[0]
cmd = old+","+new
printout("g.copy, rast="+cmd+", overwrite="+str(overwrite),lf)
grass.run_command("g.copy", rast=cmd, overwrite=overwrite)
def __init__(self, dbBase="", location="", mapset="PERMANENT"):
"""
Wrapper of "python.setup.init" defined in GRASS python.
Initialize system variables to run scripts without starting GRASS explicitly.
@param dbBase: path to GRASS database (default: '').
@param location: location name (default: '').
@param mapset: mapset within given location (default: 'PERMANENT')
@return: Path to gisrc file.
"""
self.gisbase = os.environ["GISBASE"]
self.gisdb = dbBase
self.loc = location
self.mapset = mapset
gsetup.init(self.gisbase, self.gisdb, self.loc, self.mapset)
def MakeHexagrid(gisbase,gisdb, mapset, location="cea",radius=15000, point_name="sample", point_loc="ll"):
import grass
reload(grass)
import grass.script as gscript
import grass.script.setup as gsetup
gsetup.init(gisbase,
gisdb, location, mapset)
radius=int(radius)
if radius==0:
radius = 10000
radius2 = radius*2
gscript.run_command('v.proj',location=point_loc,input=point_name,output='sample',overwrite=True,quiet=True)
gscript.run_command('g.region',vect='sample',quiet=True)
gscript.run_command('g.region',n='n+%d' % radius2 ,e='e+%d' % radius2, \
w='w-%d' % radius2,s='s-%d' % radius2,quiet=True)
gscript.run_command('v.mkgrid',flags='h',map='grid',box=(radius,radius),overwrite=True,quiet=True)
def compute_discrete_geodesic_v1():
# this a new version using r.drain to extract discrete goedesics
gisbase = os.environ['GISBASE']
gisdbdir = Parameters.gisdbdir
locationGeonet = 'geonet'
mapsetGeonet = 'geonetuser'
print gsetup.init(gisbase, gisdbdir, locationGeonet, mapsetGeonet)
# Read the filtered DEM
print 'r.in.gdal'
outfilepathgeodesic = Parameters.geonetResultsDir
outfilenamegeodesic = Parameters.demFileName
outfilenamegeodesic = outfilenamegeodesic.split('.')[0]+'_geodesicDistance.tif'
inputgeodesictifile = outfilepathgeodesic +'\\'+outfilenamegeodesic
print 'importing goedesic tif: ',inputgeodesictifile
print g.run_command('r.in.gdal', input=inputgeodesictifile, \
output=outfilenamegeodesic,overwrite=True)
# The maximum number of points is 1024
# --- have to add a check---
# -- seems to run for large point shapefiles without fail.
print 'importing channel heads shape file'
channeheadsshapefileName = Parameters.pointshapefileName
inputshapefilepath = Parameters.pointFileName
print g.run_command('v.in.ogr',input = inputshapefilepath,\
layer=channeheadsshapefileName,output=channeheadsshapefileName,\
geometry='Point')
print 'executing r.drain'
print g.run_command('r.drain',input=outfilenamegeodesic,\
output='discretegeodesicsras',\
start_points=channeheadsshapefileName)
print 'thining the discrete geodesic raster'
print g.run_command('r.thin',input='discretegeodesicsras',\
output='discretegeodesicsrasthin')
print 'converting the raster geodesic to vector map'
print g.run_command('r.to.vect',input = 'discretegeodesicsrasthin',\
output='discretegeovec', type='line')
print 'exporting the geodesics as shapefile'
print g.run_command('v.out.ogr', input= 'discretegeovec',\
output=Parameters.drainagelineFileName,\
format='ESRI_Shapefile')
print 'completed discrete geodesics'
def copy_fromtemp(cores,mapset_to,suffixes,overwrite,bregion,C,lf): # OUTSIDE
gsetup.init(gisbase, gisdbase, location, mapset_to)
for count in range(0,cores):
# Switch to temp mapset
mapset_temp = 'temp'+str(count).zfill(2)
grass.run_command("g.mapset", mapset=mapset_temp, quiet=1)
# list contents of temp mapset
raster_list = grass.list_pairs(type = 'rast')
# Switch to target mapset and copy rasters over
grass.run_command("g.mapset", mapset=mapset_to,quiet=0)
for regfilter in suffixes:
for rast in raster_list:
if(rast[1] != 'PERMANENT' and re.search(regfilter,rast[0])):
old = rast[0]+ '@' + rast[1]
new = rast[0]
cmd = old+","+new
printout("g.copy, rast="+cmd+", overwrite="+str(overwrite),lf)
grass.run_command("g.copy", rast=cmd, overwrite=overwrite)
def LoadData(gisbase,gisdb, mapset, location="ll", samplefile="sample.csv", sep=","):
# find decimalLatitude and Longitude in table
DF=read_csv(samplefile, header=0,sep=sep)
print DF.columns
Lat=[number for number,value in enumerate(DF.columns) if value=="decimalLatitude"][0]+1
Long=[number for number,value in enumerate(DF.columns) if value=="decimalLongitude"][0]+1
def MakeUp(label,size): return " ".join(["'"+label.upper()+"'","varchar({size})".format(size=size)])
form=[ MakeUp(x, DF.loc[:,x].astype("str").apply(len).max()) for x in DF.columns]
form[Lat-1]="decimalLatitude double precision"
form[Long-1]="decimalLongitude double precision"
# import GRASS Python bindings (see also pygrass)
import grass
import grass.script as gscript
import grass.script.setup as gsetup
###########
# launch session
gsetup.init(gisbase,gisdb, location, mapset)
gscript.run_command('v.in.ascii',input=samplefile,output='sample',x=Long,y=Lat,skip=1,overwrite=True,quiet=True, separator=sep)
def slopeVector(mapset, bnd, erast):
gsetup.init(evt.gisbase, evt.gisdb, 'socal_hfrd', mapset)
slopecat()
gs.parse_command('v.in.ogr',
flags='e',
input=bnd,
output=grassname(bnd),
overwrite=True,
verbose=True)
gs.parse_command('g.region',
vect=grassname(bnd))
gs.parse_command('r.in.gdal',
input=erast,
output=grassname(erast),
overwrite=True,
verbose=True)
gs.parse_command('r.slope.aspect',
elevation=grassname(erast),
slope=grassname(erast)+'slp',
format='percent',
overwrite=True,
verbose=True)
gs.parse_command('g.region',
rast=grassname(erast)+'slp')
gs.parse_command('r.recode',
input=grassname(erast)+'slp',
output=grassname(erast)+'slprc',
rules='slp_reclass',
overwrite=True,
verbose=True)
gs.parse_command('r.to.vect',
flags='s',
input=grassname(erast)+'slprc',
output=grassname(bnd)+'slope',
type_='area',
verbose=True,
overwrite=True)
gs.parse_command('v.out.postgis',
input=grassname(bnd)+'slope',
output="PG:dbname=hfrd",
overwrite=True,
options="SRID=98226")
def grass_config(location, mapset, gisbase='/usr/local/grass-6.4.5svn', gisdbase='.'):
""" Set grass environment to run grass.script as grass
"""
os.environ['GISBASE'] = gisbase
os.environ['GRASS_VERBOSE'] = '0'
os.environ['GRASS_OVERWRITE'] = '1'
sys.path.append(os.path.join(gisbase, 'etc', 'python'))
global grass
__import__('grass.script')
grass = sys.modules['grass.script']
from grass.script.setup import init
gisrc = init(gisbase, gisdbase, location, mapset)
def main(gisdb,georeffile,gisrc,loc='tuolumneCA',mapsets=['wind']):
location_path = os.path.join(gisdb, loc)
# Create new location
startcmd = 'grass70 -c ' + georeffile + ' -e ' + location_path
print startcmd
p = subprocess.Popen(startcmd, shell=True,
stdout=subprocess.PIPE, stderr=subprocess.PIPE)
out, err = p.communicate()
if p.returncode != 0:
print >>sys.stderr, 'ERROR: %s' % err
print >>sys.stderr, 'ERROR: Cannot generate location (%s)' % startcmd
sys.exit(-1)
else:
print 'Created location %s' % location_path
# Now the location with PERMANENT mapset exists.
########
# Launch session and do something
gisbase = os.environ.get('GISBASE')
gsetup.init(gisbase, gisdb, loc, 'PERMANENT')
for ms in mapsets:
gscript.run_command('g.mapset', flags='c',
verbose=True,
mapset=ms,
location=loc,
dbase=gisdb)
# Write gisrc file
with open(gisrc,'w') as rc:
rc.write("GISDBASE: %s\n" % gisdb)
rc.write("LOCATION_NAME: %s\n" % loc)
rc.write("MAPSET: PERMANENT")
import os
import sys
import csv
GISBASE = os.environ['GISBASE'] = '/home/majavie/grass_last/grass-7.1.svn'
gisdbase = os.path.join("/local1/majavie/hanksgrass7")
location = "global_MW"
mapset = "rasterized_parks"
sys.path.append(os.path.join(os.environ['GISBASE'], "etc", "python"))
import grass.script as grass
import grass.script.setup as gsetup
gsetup.init(GISBASE,
gisdbase, location, mapset)
print grass.gisenv()
source = 'wdpa_snapshot_new_mollweide@javier'
grass. message ("Extracting list of PAs")
pa_list0 = grass. read_command ('v.db.select', map=source,column='wdpa_id'). splitlines ()
pa_list2 = np.unique(pa_list0)
n = len(pa_list2)-1#2
#pa_list = pa_list2[0:n]
pa_list = '257','101922','2017','11','68175','643','555542456' # testing set
csvname1 = 'pas_segm_done.csv'
if os.path.isfile(csvname1) == False:
wb = open(csvname1,'a')
wb.write('None')
def fsegm(pa):
#gc.collect()
pa_list_done = np.genfromtxt(csvname1,dtype='string')
### mp.current_process().cnt += 1
if pa not in pa_list_done:
current = multiprocessing.current_process()
mn = current._identity[0]
print 'running:', mn
#rmk = 'MASK=if(MASK>0,MASK,0)'
#rmk = 'MASK = if( MASK > 0 , MASK , 0)'
GISBASE = os.environ['GISBASE'] = "/home/majavie/hierba_hanks/grass-7.1.svn"
GRASSDBASE = "/home/majavie/hanksgrass7"
MYLOC = "global_MW"
mapset = 'm'
sys.path.append(os.path.join(os.environ['GISBASE'], "etc", "python"))
import grass.script as grass
import grass.script.setup as gsetup
gsetup.init(GISBASE, GRASSDBASE, MYLOC, mapset)
#sys.path.append(os.path.join(os.environ['GISBASE'], "etc", "python"))
#import grass.script as grass
#import grass.script.setup as gsetup
mapset2 = 'm'+str(mn)#ehabitat'
os.system ('rm -rf /home/majavie/hanksgrass7/global_MW/'+mapset2)
#os.system ('grass70 -c -text /home/majavie/hanksgrass7/global_MW/'+mapset2)
col= 'wdpaid'
grass.run_command('g.mapset',mapset=mapset2,location='global_MW',gisdbase='/home/majavie/hanksgrass7',flags='c')
os.system('rm csv/*_'+str(pa)+'_*')
os.system('rm shp/*_'+str(pa)+'_*')
gsetup.init(GISBASE, GRASSDBASE, MYLOC, mapset2)
print pa, mapset2, grass.gisenv()
ong = str(pa)+str(mapset2)+str(grass.gisenv())
grass.run_command('g.mapsets',mapset='ehabitat,rasterized_parks',operation='add')
source = 'wdpa_aug14_100km2_moll'
wb = open(csvong1,'a')
wb.write(ong)
wb.write('\n')
wb.close()
#grass.run_command('g.remove',group='segm')
#grass.run_command('r.mask',flags='r')
#grass.run_command('g.rename',rast='MASK,masc',overwrite=True)
#grass.run_command('g.mremove',typ='vect',patt='*',flags='f')
#grass.run_command('g.mremove',typ='rast',patt='*',flags='bf')
reps = [0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9]
#if os.path.isfile('/home/majavie/hanksgrass7/global_MW/'+mapset2+'/group/segm/REF') == True:
# os.system ('rm /home/majavie/hanksgrass7/global_MW/'+mapset2+'/group/segm/REF')
print pa
pa44 = 'pa_'+str(pa)
pa44x = 'pax_'+str(pa)
pa0 = 'v0_'+pa
opt1 = col+'='+pa
grass.run_command('v.extract', input=source, out=pa0, where = opt1,overwrite=True) # check inital region from which to copy from!
pa2 = pa+'v2_'
pa3 = pa+'v3'
pa4 = 'paa_'+pa
pa5 = pa4+'.txt'
same = pa2+'= const'
#grass. message ("setting up the working region")
grass.run_command('g.region',vect=pa0,res=1000)
grass.run_command('r.mapcalc',expression='const = if(gcmask>=0,1,null())',overwrite=True)
grass.run_command('r.mapcalc',expression=same,overwrite=True)
a = grass.read_command('r.stats',input='const',flags='nc',separator='\n').splitlines()
if len(a)==0: a = [1, 625]
#print a
minarea = np.sqrt(int(a[1]))#/2 #10
minaream = minarea#*1000
grass.run_command('i.pca', flags='n', input='pre,eprsqrt,slope,tree,herb,ndwi,ndvimax2,ndvimin,bio', output=pa44x, overwrite=True) # dem
pca1 = pa44x+'.1'
pca2 = pa44x+'.2'
pca3 = pa44x+'.3'
pcas = pca1+','+pca2+','+pca3
grass.run_command('i.group',gr='segm',input=pcas)
os.system ('cat /home/majavie/hanksgrass7/global_MW/'+mapset2+'/group/segm/REF')
j = 0
for thr in reps:
pa2 = pa+'v2_'+str(j)
pa2s = pa+'v2_'+str(j-1)
aleat = np.random.random_integers(1000)
grass.run_command('g.region',vect=pa0,res=1000)
j= j + 1
if thr==0.1:
grass.run_command('i.segment', group='segm', output=pa2, threshold=thr, method='region_growing', minsize=minarea, similarity='euclidean', memory='100000', iterations='20',overwrite=True) # ,seed=pa2i minsize=minarea,
else:
grass.run_command('i.segment', group='segm', output=pa2, threshold=thr, method='region_growing', similarity='euclidean', memory='100000', iterations='20',seed=pa2s,overwrite=True) # minsize=minarea
#grass. message ("cropping the segments")
grass.run_command('r.mask', vector=source, where=opt1)
opt2 = pa3+'='+pa2
grass.run_command('r.mapcalc',expression=opt2,overwrite=True) # usar const como mapa para crear plantilla de PA con unos y ceros
grass.run_command('g.rename',rast='MASK,masc',overwrite=True)
#grass.run_command('g.remove', rast='MASK')
print minarea
b = grass.read_command('r.stats',input=pa3,flags='nc',separator='\n').splitlines()
print b
clean = None
c = pa3
for g in np.arange(1,len(b),2):
if np.int(b[g]) < minarea:#/10: # lower the threshold if omitting min area!
print 'Cleaning small segments I...'
print 'cleaning cat '+ str(b[g-1])
c2 = 'old'+ str(b[g-1])
c22 = c2+'b10km'
c3 = 'new'+ str(b[g-1])
oper1 = c2+'='+'if('+pa3+'=='+str(b[g-1])+',1,null())'
grass.run_command('r.mapcalc',expression=oper1,overwrite=True)
grass.run_command('r.buffer',input=c2,output=c22,distances=3,units='kilometers',overwrite=True)
grass.run_command('r.mask', raster=c22,maskc=2)
buff = grass.read_command('r.stats',input=pa3,flags='nc',sort='desc',separator='\n').splitlines()
grass.run_command('g.rename',rast='MASK,masc',overwrite=True)
#grass.run_command('g.remove', rast='MASK')
if len(buff) > 0:
clean = 'T'
print 'New: '+str(buff[0])
oper1 = c3+'='+'if('+c2+'==1,'+str(buff[0])+',null())'
c = c3 + ',' + c
grass.run_command('r.mapcalc',expression=oper1,overwrite=True)
if clean=='T':
print c
grass.run_command('r.patch',input=c,out=pa3,overwrite=True)
bv = grass.read_command('r.stats',input=pa3,flags='nc',separator='\n').splitlines()
print bv
b = grass.read_command('r.stats',input=pa3,flags='nc',separator='\n').splitlines()
print b
clean = None
c = pa3
for g in np.arange(1,len(b),2):
if np.int(b[g]) < minarea:#/10: # lower the threshold if omitting min area!
print 'Cleaning small segments II...'
print 'cleaning cat '+ str(b[g-1])
c2 = 'old'+ str(b[g-1])
c22 = c2+'b10km'
c3 = 'new'+ str(b[g-1])
oper1 = c2+'='+'if('+pa3+'=='+str(b[g-1])+',1,null())'
grass.run_command('r.mapcalc',expression=oper1,overwrite=True)
grass.run_command('r.buffer',input=c2,output=c22,distances=10,units='kilometers',overwrite=True)
grass.run_command('r.mask', raster=c22,maskc=2)
buff = grass.read_command('r.stats',input=pa3,flags='nc',sort='desc',separator='\n').splitlines()
grass.run_command('g.rename',rast='MASK,masc',overwrite=True)
#grass.run_command('g.remove', rast='MASK')
if len(buff) > 0:
clean = 'T'
print 'New: '+str(buff[0])
oper1 = c3+'='+'if('+c2+'==1,'+str(buff[0])+',null())'
c = c3 + ',' + c
grass.run_command('r.mapcalc',expression=oper1,overwrite=True)
if clean=='T':
print c
grass.run_command('r.patch',input=c,out=pa3,overwrite=True)
bv = grass.read_command('r.stats',input=pa3,flags='nc',separator='\n').splitlines()
print bv
b = grass.read_command('r.stats',input=pa3,flags='nc',sort='desc',separator='\n').splitlines()
print b
for g in np.arange(1,len(b),2):
if np.int(b[g]) < minarea:#/10: # lower the threshold if omitting min area!
print 'Cleaning small segments III...'
print 'cleaning cat '+ str(b[g-1])
oper1 = pa3+'='+'if('+pa3+'=='+str(b[g-1])+','+str(b[0])+','+pa3+')'
grass.run_command('r.mapcalc',expression=oper1,overwrite=True)
bv = grass.read_command('r.stats',input=pa3,flags='nc',separator='\n').splitlines()
print bv
#grass. message ("Number of cells per segment")
#grass.run_command('r.stats',input=pa3,out=pa5,overwrite=True) # flags='nc'
#grass. message ("converting to vector")
grass.run_command('r.to.vect', input=pa3,out=pa4,type ='area',flags='v',overwrite=True)
#grass. message ("adding labels to segments")
grass.run_command('v.db.addcolumn', map=pa4,col='wdpaid_pa VARCHAR')
grass.run_command('v.db.update', map=pa4,col='wdpaid_pa',value=pa)
grass.run_command('v.db.addcolumn', map=pa4,col='aleat VARCHAR')
grass.run_command('v.db.update', map=pa4,col='aleat',value=aleat)
#grass. message ("Checking shapefile")
pa44 = pa4
pa442 = pa44+'_diss'
#grass.run_command('v.clean', input=pa4,out=pa44,tool='rmarea',thres=minaream,overwrite=True)
grass.run_command('v.db.addcolumn', map=pa44,col='segm_id numeric')#VARCHAR')
grass.run_command('v.db.update', map=pa44,col='segm_id',qcol='wdpaid_pa || cat || aleat')
#grass. message ("Exporting shapefile")
name = 'shp/park_segm_'+str(pa)+'_'+str(j)
if os.path.isfile(name+'.shp') == False:
grass.run_command('v.out.ogr',input=pa44,ola=name,type='area',dsn='.')
else:
grass.run_command('v.out.ogr',flags='a',input=pa44,ola=name,type='area',dsn='.')
grass. message ("Done1")
#grass.run_command('v.in.ogr',flags='oe',dsn='.',lay=name,out=name,overwrite=True)
spa_list0 = grass. read_command ('v.db.select', map=pa44,column='segm_id'). splitlines ()
spa_list = np.unique(spa_list0)
print spa_list
# save it as a csv excluding last item!
grass. message("omitting previous masks")
grass.run_command('g.rename',rast='MASK,masc',overwrite=True)
#grass.run_command('g.remove', rast='MASK')
#pa_list_done = np.genfromtxt(csvname1,dtype='string')
sn = len(spa_list)-1 # there is also a segm_id element!
for spx in range(0,sn): # 0
spa = spa_list[spx]
spa2 = 'svv'+spa
#pa3 = pa+'v3'
spa4 = 'spa_'+spa
spa5 = 'tiffs/pa_'+spa+'.tif'
spa0 = 'sv0_'+spa
sopt1 = 'segm_id = '+spa
#if pa not in pa_list_done:
print spx
print "Extracting PA:"+spa
grass.run_command('v.extract', input=pa44, out=spa0, where = sopt1,overwrite=True)
# try to crop PAs shapefile with coastal line or input vars
grass. message ("setting up the working region")
grass.run_command('g.region',vect=spa0,res=1000)
grass.run_command('v.to.rast',input=spa0,out=spa0,use='val')#use='cat',labelcol='segm_id')
soptt = spa4+'='+spa0
grass.run_command('r.mask', rast='pre') # new to crop parks to where we have indicators information
grass.run_command('r.mapcalc',expression=soptt,overwrite=True) # opt3
grass.run_command('g.rename',rast='MASK,masc',overwrite=True)
#grass.run_command('g.remove', rast='MASK') # new
grass.run_command('r.null',map=spa4,null=0)
econame = 'csv/park_'+str(pa)+'_'+str(j)+'.csv'
eco = str(j)
econ = 'csv/ecoregs'+str(j)+'.csv'
grass.run_command('r.out.gdal',input=spa4,out=spa5,overwrite=True)
# grass. message ("Deleting tmp layers")
wb = open(econame,'a')
wb.write(spa)
wb.write('\n')
wb.close()
wb = open(econ,'a')
wb.write(eco)
wb.write('\n')
wb.close()
grass. message ("Deleting tmp layers")
#grass.run_command('g.mremove',typ='vect',patt='*',flags='f')
#grass.run_command('g.mremove',typ='rast',patt='*',flags='bf')
#grass.run_command('g.rename',rast='MASK,masc',overwrite=True)
#grass.run_command('g.remove', rast='MASK')
os.system ('rm -rf /home/majavie/hanksgrass7/global_MW/'+mapset2)
wb = open(csvong2,'a')
wb.write(ong)
wb.write('\n')
wb.close()
wb = open(csvname1,'a')
var = str(pa)
wb.write(var)
wb.write('\n')
wb.close()
import os
import sys
metadata = {
"grass_dbase" : "/home/ga/ga_cms/src/DR5/GRASSData",
"grass_location" : "DR5",
"grass_mapset" : "taehee",
}
grassDbase = metadata['grass_dbase']
os.environ['GISBASE'] = gisBase = "/usr/lib/grass64"
sys.path.append(os.path.join(gisBase, "etc", "python"))
import grass.script as grass
import grass.script.setup as gsetup
gsetup.init(gisBase, grassDbase, metadata['grass_location'], metadata['grass_mapset'])
from tqdm import *
import os
import sys
import csv
GISBASE = os.environ['GISBASE'] = "/home/majavie/grass_last/new/grass7_trunk/dist.x86_64-unknown-linux-gnu"
GRASSDBASE = "/local0/majavie/hanksgrass7"
MYLOC = "global_MW"
mapset = 'ehabitat'
col= 'wdpaid'
sys.path.append(os.path.join(os.environ['GISBASE'], "etc", "python"))
import grass.script as grass
import grass.script.setup as gsetup
gsetup.init(GISBASE, GRASSDBASE, MYLOC, mapset)
source = 'wdpa_aug14_100km2_moll'
grass. message ("Extracting list of PAs")
pa_list0 = grass. read_command ('v.db.select', map=source,column=col). splitlines ()
pa_list2 = np.unique(pa_list0)
n = len(pa_list2)
pa_list = pa_list2[0:n-2] # testing 5 first!
#pa_list = '257','101922','2017','11','68175','643','555542456'
print pa_list
csvname1 = 'pas_segm_done.csv'
if os.path.isfile(csvname1) == False:
wb = open(csvname1,'a')
wb.write('None')
wb.write('\n')
wb.close()
def SC(jobid, xlon, ylat, prj):
dem_full_path = DEM_FULL_PATH
dem = DEM_NAME
drainage_full_path = DRAINAGE_FULL_PATH
drainage = DRAINAGE_NAME
gisbase = GISBASE
grass7bin = GRASS7BIN
# Define grass data folder, location, mapset
gisdb = os.path.join(tempfile.gettempdir(), 'grassdata')
if not os.path.exists(gisdb):
os.mkdir(gisdb)
location = "location_{0}".format(dem)
mapset = "PERMANENT"
msg = ""
# Create log file for each job
log_name = 'log_{0}.log'.format(jobid)
log_path = os.path.join(gisdb, log_name)
f = open(log_path, 'w', 0)
# Create output_data folder path
output_data_path = OUTPUT_DATA_PATH
if not os.path.exists(output_data_path):
os.mkdir(output_data_path)
try:
# Create location
location_path = os.path.join(gisdb, location)
if not os.path.exists(location_path):
f.write('\n---------Create Location from DEM--------------------\n')
f.write('{0}\n'.format(location_path))
startcmd = grass7bin + ' -c ' + dem_full_path + ' -e ' + location_path
print startcmd
p = subprocess.Popen(startcmd, shell=True,
stdout=subprocess.PIPE, stderr=subprocess.PIPE)
out, err = p.communicate()
if p.returncode != 0:
print >>sys.stderr, 'ERROR: %s' % err
print >>sys.stderr, 'ERROR: Cannot generate location (%s)' % startcmd
f.write('\n---------Create Location failed--------------------\n')
sys.exit(-1)
else:
f.write('\n---------Create Location done--------------------\n')
print 'Created location %s' % location_path
xlon = float(xlon)
ylat = float(ylat)
outlet = (xlon, ylat)
# Set GISBASE environment variable
os.environ['GISBASE'] = gisbase
# the following not needed with trunk
os.environ['PATH'] += os.pathsep + os.path.join(gisbase, 'extrabin')
# Set GISDBASE environment variable
os.environ['GISDBASE'] = gisdb
# define GRASS-Python environment
gpydir = os.path.join(gisbase, "etc", "python")
sys.path.append(gpydir)
f.write('\n---------sys.path--------------------\n')
f.write('\n'.join(sys.path))
f.write('\n----------sys.version-------------------\n')
f.write(sys.version)
f.write('\n----------os.environ-----------------\n')
f.write(str(os.environ))
# import GRASS Python bindings (see also pygrass)
import grass.script as gscript
import grass.script.setup as gsetup
gscript.core.set_raise_on_error(True)
# launch session
gsetup.init(gisbase, gisdb, location, mapset)
f.write(str(gscript.gisenv()))
# Check the dem file, import if not exist
dem_mapset_path = location_path = os.path.join(gisdb, location, mapset, "cell", dem)
if not os.path.exists(dem_mapset_path):
f.write("\n ---------- import DEM file ------------- \n")
stats = gscript.read_command('r.in.gdal', input=dem_full_path, output=dem)
#import drainage
drainage_mapset_path = location_path = os.path.join(gisdb, location, mapset, "cell", drainage)
if not os.path.exists(drainage_mapset_path):
f.write("\n ---------- import Drainage file ------------- \n")
stats = gscript.read_command('r.in.gdal', input=drainage_full_path, output=drainage)
# List all files in location to check if the DEM file imported successfully
f.write("\n ---------- List raster ------------- \n")
for rast in gscript.list_strings(type='rast'):
f.write(str(rast))
f.write("\n ---------- List vector ------------- \n")
for vect in gscript.list_strings(type='vect'):
f.write(str(vect))
f.write("\n ---------------------------JOB START-------------------------------- \n")
f.write(str(datetime.now()))
# Project xlon, ylat wgs84 into current
if prj.lower() != "native" or prj.lower() == "wgs84":
f.write("\n ---------- Reproject xlon and ylat into native dem projection ------------- \n")
stats = gscript.read_command('m.proj', coordinates=(xlon, ylat), flags='i')
coor_list = stats.split("|")
xlon = float(coor_list[0])
ylat = float(coor_list[1])
outlet = (xlon, ylat)
# Define region
f.write("\n ---------- Define region ------------- \n")
stats = gscript.parse_command('g.region', raster=dem, flags='p')
f.write(str(stats))
# Read extent of the dem file
for key in stats:
if "north:" in key:
north = float(key.split(":")[1])
elif "south:" in key:
south = float(key.split(":")[1])
elif "west:" in key:
west = float(key.split(":")[1])
elif "east:" in key:
east = float(key.split(":")[1])
elif "nsres:" in key:
nsres = float(key.split(":")[1])
elif "ewres:" in key:
ewres = float(key.split(":")[1])
# check if xlon, ylat is within the extent of dem
if xlon < west or xlon > east:
f.write("\n ERROR: xlon is out of dem region. \n")
raise Exception("(xlon, ylat) is out of dem region.")
elif ylat < south or ylat > north:
f.write("\n ERROR: ylat is out of dem region. \n")
raise Exception("(xlon, ylat) is out of dem region.")
# Flow accumulation analysis
f.write("\n ---------- Flow accumulation analysis ------------- \n")
if not os.path.exists(drainage_mapset_path):
stats = gscript.read_command('r.watershed', elevation=dem, threshold='10000', drainage=drainage, flags='s', overwrite=True)
# Delineate watershed
f.write("\n ---------- Delineate watershed ------------- \n")
basin = "{0}_basin_{1}".format(dem, jobid)
stats = gscript.read_command('r.water.outlet', input=drainage, output=basin, coordinates=outlet, overwrite=True)
# output lake
# r.mapcalc expression="lake_285.7846_all_0 = if( lake_285.7846, 0)" --o
f.write("\n -------------- Set all values of raster basin to 0 ----------------- \n")
basin_all_0 = "{0}_all_0".format(basin)
mapcalc_cmd = '{0} = if({1}, 0)'.format(basin_all_0, basin)
gscript.mapcalc(mapcalc_cmd, overwrite=True, quiet=True)
# covert raster lake_rast_all_0 into vector
# r.to.vect input='lake_285.7846_all_0@drew' output='lake_285_all_0_vec' type=area --o
f.write("\n -------------- convert raster lake_rast_all_0 into vector ----------------- \n")
basin_all_0_vect = "{0}_all_0_vect".format(basin)
f.write("\n -------------- {0} ----------------- \n".format(basin_all_0_vect))
stats = gscript.parse_command('r.to.vect', input=basin_all_0, output=basin_all_0_vect, type="area", overwrite=True)
# output GeoJSON
# v.out.ogr -c input='lake_285_alll_0_vec' output='/tmp/lake_285_all_0_vec.geojson' format=GeoJSON type=area --overwrite
geojson_f_name = "{0}.GEOJSON".format(basin)
basin_GEOJSON = os.path.join(output_data_path, geojson_f_name)
stats = gscript.parse_command('v.out.ogr', input=basin_all_0_vect, output=basin_GEOJSON, \
format="GeoJSON", type="area", overwrite=True, flags="c")
f.write("\n-------------------------END--------------------------\n")
f.write(str(datetime.now()))
f.close()
return basin_GEOJSON, msg
except Exception as e:
print e.message
msg = e.message
if f is not None:
f.write("\n-------------!!!!!! ERROR !!!!!!--------------\n")
f.write(e.message)
f.close()
return None, msg
def SC(jobid, xlon, ylat, prj, damh, interval, output_lake=False):
logger.info("run SC")
dem_full_path = DEM_FULL_PATH
dem = DEM_NAME
drainage_full_path = DRAINAGE_FULL_PATH
drainage = DRAINAGE_NAME
gisbase = GISBASE
grass7bin = GRASS7BIN
gisdb = GISDB
# Define grass data folder, location, mapset
if not os.path.exists(gisdb):
os.mkdir(gisdb)
location = "location_{0}".format(dem)
mapset = "PERMANENT"
keep_intermediate = False
msg = ""
# Create log file for each job
logs_path = LOGS_PATH
if not os.path.exists(logs_path):
os.mkdir(logs_path)
log_name = 'log_{0}.log'.format(jobid)
f = open(os.path.join(logs_path, log_name), 'w', 0)
# Create output_data folder path
output_data_path = OUTPUT_DATA_PATH
if not os.path.exists(output_data_path):
os.mkdir(output_data_path)
temp_files_list = []
result = {}
result['jobid'] = jobid
try:
# Create location
location_path = os.path.join(gisdb, location)
if not os.path.exists(location_path):
f.write('\n---------Create Location from DEM--------------------\n')
f.write('{0}\n'.format(location_path))
startcmd = grass7bin + ' -c ' + dem_full_path + ' -e ' + location_path
print startcmd
p = subprocess.Popen(startcmd, shell=True,
stdout=subprocess.PIPE, stderr=subprocess.PIPE)
out, err = p.communicate()
if p.returncode != 0:
print >>sys.stderr, 'ERROR: %s' % err
print >>sys.stderr, 'ERROR: Cannot generate location (%s)' % startcmd
f.write('\n---------Create Location failed--------------------\n')
sys.exit(-1)
else:
f.write('\n---------Create Location done--------------------\n')
print 'Created location %s' % location_path
xlon = float(xlon)
ylat = float(ylat)
outlet = (xlon, ylat)
dam_h = float(damh)
elev_interval = dam_h/interval
# Set GISBASE environment variable
os.environ['GISBASE'] = gisbase
# the following not needed with trunk
os.environ['PATH'] += os.pathsep + os.path.join(gisbase, 'extrabin')
# Set GISDBASE environment variable
os.environ['GISDBASE'] = gisdb
# define GRASS-Python environment
gpydir = os.path.join(gisbase, "etc", "python")
sys.path.append(gpydir)
f.write('\n---------sys.path--------------------\n')
f.write('\n'.join(sys.path))
f.write('\n----------sys.version-------------------\n')
f.write(sys.version)
f.write('\n----------os.environ-----------------\n')
f.write(str(os.environ))
# import GRASS Python bindings (see also pygrass)
import grass.script as gscript
import grass.script.setup as gsetup
gscript.core.set_raise_on_error(True)
# launch session
gsetup.init(gisbase, gisdb, location, mapset)
f.write(str(gscript.gisenv()))
# Check dem file, import if not exist
dem_in_mapset_path = location_path = os.path.join(gisdb, location, mapset, "cell", dem)
if not os.path.exists(dem_in_mapset_path):
f.write("\n ---------- import DEM file ------------- \n")
stats = gscript.read_command('r.in.gdal', input=dem_full_path, output=dem)
#import drainage
drainage_mapset_path = location_path = os.path.join(gisdb, location, mapset, "cell", drainage)
if not os.path.exists(drainage_mapset_path):
f.write("\n ---------- import Drainage file ------------- \n")
stats = gscript.read_command('r.in.gdal', input=drainage_full_path, output=drainage)
# List all files in location to check if the DEM file imported successfully
f.write("\n ---------- raster ------------- \n")
for rast in gscript.list_strings(type='rast'):
f.write(str(rast))
f.write("\n ---------- vector ------------- \n")
for vect in gscript.list_strings(type='vect'):
f.write(str(vect))
f.write("\n ---------------------------JOB START-------------------------------- \n")
f.write(str(datetime.now()))
# Project xlon, ylat wgs84 into current
if prj.lower() != "native" or prj.lower() == "wgs84":
f.write("\n ---------- Reproject xlon and ylat into native dem projection ------------- \n")
stats = gscript.read_command('m.proj', coordinates=(xlon, ylat), flags='i')
coor_list = stats.split("|")
xlon = float(coor_list[0])
ylat = float(coor_list[1])
outlet = (xlon, ylat)
# Define region
f.write("\n ---------- Define region ------------- \n")
stats = gscript.parse_command('g.region', raster=dem, flags='p')
f.write(str(stats))
# Read extent of the dem file
for key in stats:
if "north:" in key:
north = float(key.split(":")[1])
elif "south:" in key:
south = float(key.split(":")[1])
elif "west:" in key:
west = float(key.split(":")[1])
elif "east:" in key:
east = float(key.split(":")[1])
elif "nsres:" in key:
nsres = float(key.split(":")[1])
elif "ewres:" in key:
ewres = float(key.split(":")[1])
# check if xlon, ylat is within the extent of dem
if xlon < west or xlon > east:
f.write("\n ERROR: xlon is out of dem region. \n")
raise Exception("(xlon, ylat) is out of dem region.")
elif ylat < south or ylat > north:
f.write("\n ERROR: ylat is out of dem region. \n")
raise Exception("(xlon, ylat) is out of dem region.")
# Calculate cell area
cell_area = nsres * ewres
# Flow accumulation analysis
f.write("\n ---------- Flow accumulation analysis ------------- \n")
if not os.path.exists(drainage_mapset_path):
stats = gscript.read_command('r.watershed', elevation=dem, threshold='10000', drainage=drainage, flags='s', overwrite=True)
# Delineate watershed
f.write("\n ---------- Delineate watershed ------------- \n")
basin = "{0}_{1}_basin".format(dem, jobid)
temp_files_list.append(basin)
stats = gscript.read_command('r.water.outlet', input=drainage, output=basin, coordinates=outlet, overwrite=True)
# Cut dem with watershed
f.write("\n -------------- Cut dem ----------------- \n")
dem_cropped = "{0}_{1}_cropped".format(dem, jobid)
mapcalc_cmd = '{0} = if({1}, {2})'.format(dem_cropped, basin, dem)
temp_files_list.append(dem_cropped)
gscript.mapcalc(mapcalc_cmd, overwrite=True, quiet=True)
# Read outlet elevation
f.write("\n ---------- Read outlet elevation ------------- \n")
outlet_info = gscript.read_command('r.what', map=dem, coordinates=outlet)
f.write("\n{0} \n".format(outlet_info))
outlet_elev = outlet_info.split('||')[1]
try:
outlet_elev = float(outlet_elev)
except Exception as e:
f.write("{0} \n".format(e.message))
raise Exception("This point has no data.")
f.write("------------Outlet elevation--{0} ---------------- \n".format(outlet_elev))
# Create a list including elevations of all interval points
dam_elev = outlet_elev + dam_h
elev_list = []
elev = outlet_elev + elev_interval
while elev < dam_elev:
elev_list.append(elev)
elev += elev_interval
elev_list.append(dam_elev)
f.write("\n----------Elevation list----------\n")
f.write(str(elev_list))
#For each interval point, calculate reservior volume
f.write("\n ------------- Reservoir volume calculation ---------------- \n")
storage_list = []
lake_output_list = []
count = 0
for elev in elev_list:
count += 1
f.write(str(elev))
f.write(", ")
# Generate reservoir raster file
f.write("\n-----------Generate lake file ---------- No.{}\n".format(count))
lake_rast = '{0}_{1}_lake_{2}'.format(dem, jobid, str(int(elev)))
temp_files_list.append(lake_rast)
stats = gscript.read_command('r.lake', elevation=dem_cropped, coordinates=outlet, waterlevel=elev, lake=lake_rast, overwrite=True)
#Calculate reservoir volume
f.write("\n-----------Calculate lake volume --------- No.{}\n".format(count))
stats = gscript.parse_command('r.univar', map=lake_rast, flags='g')
f.write("\n{0}\n".format(str(stats)))
sum_height = float(stats['sum'])
f.write("\n-------Cell area--{0}----------\n".format(str(cell_area)))
volume = sum_height * cell_area
storage = (volume, elev)
print("\nNo. {0}--------> sc is {1} \n".format(count, str(storage)))
storage_list.append(storage)
if output_lake:
# output lake
# r.mapcalc expression="lake_285.7846_all_0 = if( lake_285.7846, 0)" --o
f.write("\n -------------- Set all values of raster lake to 0 ----------------- \n")
lake_rast_all_0 = "{0}_all_0".format(lake_rast)
mapcalc_cmd = '{0} = if({1}, 0)'.format(lake_rast_all_0, lake_rast)
gscript.mapcalc(mapcalc_cmd, overwrite=True, quiet=True)
# covert raster lake_rast_all_0 into vector
# r.to.vect input='lake_285.7846_all_0@drew' output='lake_285_all_0_vec' type=area --o
f.write("\n -------------- convert raster lake_rast_all_0 into vector ----------------- \n")
lake_rast_all_0_vec = "{0}_all_0_vect".format(lake_rast)
lake_rast_all_0_vec = lake_rast_all_0_vec.replace(".", "_")
f.write("\n -------------- {0} ----------------- \n".format(lake_rast_all_0_vec))
stats = gscript.parse_command('r.to.vect', input=lake_rast_all_0, output=lake_rast_all_0_vec, type="area", overwrite=True)
# output GeoJSON
# v.out.ogr -c input='lake_285_all_0_vec' output='/tmp/lake_285_all_0_vec.geojson' format=GeoJSON type=area --overwrite
geojson_f_name = "{0}.GEOJSON".format(lake_rast.replace(".", "_"))
lake_rast_all_0_vec_GEOJSON = os.path.join(output_data_path, geojson_f_name)
stats = gscript.parse_command('v.out.ogr', input=lake_rast_all_0_vec, output=lake_rast_all_0_vec_GEOJSON, \
format="GeoJSON", type="area", overwrite=True, flags="c")
# output KML
# v.out.ogr -c input='lake_285_all_0_vec' output='/tmp/lake_285_all_0_vec.KML' format=KML type=area --overwrite
kml_f_name = "{0}.KML".format(lake_rast.replace(".", "_"))
lake_rast_all_0_vec_KML = os.path.join(output_data_path, kml_f_name)
stats = gscript.parse_command('v.out.ogr', input=lake_rast_all_0_vec, output=lake_rast_all_0_vec_KML, \
format="KML", type="area", overwrite=True, flags="c")
output_tuple = (str(elev), geojson_f_name, kml_f_name)
lake_output_list.append(output_tuple)
zero_point = (0, outlet_elev)
storage_list.insert(0, zero_point)
for sc in storage_list:
f.write(str(sc))
f.write("\n")
f.write("\n-------------------------END--------------------------\n")
f.write(str(datetime.now()))
f.close()
keep_intermediate = True
result['status'] = 'success'
result['storage_list'] = storage_list
result['lake_output_list'] = lake_output_list
result['msg'] = msg
return result
except Exception as e:
keep_intermediate = True
print e.message
msg = e.message
if f is not None:
f.write("\n-------------!!!!!! ERROR !!!!!!--------------\n")
f.write(e.message)
f.close()
result['status'] = 'error'
result['storage_list'] = None
result['lake_output_list'] = None
result['msg'] = msg
return result
finally:
save_result_to_db(jobid, result)
# Remove all temp files
if not keep_intermediate:
for f in temp_files_list:
f_fullpath = "{0}/{1}/{2}/cell/{3}".format(gisdb, location, mapset, f)
if os.path.exists(f_fullpath):
os.remove(f_fullpath)
finally:
try:
grass.run_command('g.remove', type='vector', name=tmp_vect, flags='f')
except:
pass
outfile.close()
if __name__ == "__main__":
gisbase = os.environ['GISBASE']
gisdbase = os.environ['GISDBASE']
location = os.environ['LOCATION_NAME']
# Find mapset in params:
for param in sys.argv:
if not 'mapset=' in param:
continue
else:
break
mapset = param.split('=')[1]
sys.path.append(os.path.join(os.environ['GISBASE'], "etc", "python"))
from grass.script.core import gisenv
import grass.script as grass
import grass.script.setup as gsetup
gsetup.init(gisbase, gisdbase, location, mapset)
options, flags = grass.parser()
sys.exit(main(options, flags))
