def run_r_sun(elevation, aspect, slope, day, time, linke, linke_value, albedo,
albedo_value, beam_rad, diff_rad, refl_rad, glob_rad, incidout,
suffix, binary, binaryTmpName, flags):
params = {}
if linke:
params.update({'linke': linke})
if linke_value:
params.update({'linke_value': linke_value})
if albedo:
params.update({'albedo': albedo})
if albedo_value:
params.update({'albedo_value': albedo_value})
if beam_rad:
params.update({'beam_rad': beam_rad + suffix})
if diff_rad:
params.update({'diff_rad': diff_rad + suffix})
if refl_rad:
params.update({'refl_rad': refl_rad + suffix})
if glob_rad:
params.update({'glob_rad': glob_rad + suffix})
if incidout:
params.update({'incidout': incidout + suffix})
if flags:
params.update({'flags': flags})
if is_grass_7():
grass.run_command('r.sun',
elevation=elevation,
aspect=aspect,
slope=slope,
day=day,
time=time,
overwrite=core.overwrite(),
quiet=True,
**params)
else:
grass.run_command('r.sun',
elevin=elevation,
aspin=aspect,
slopein=slope,
day=day,
time=time,
overwrite=core.overwrite(),
quiet=True,
**params)
if binary:
for output in (beam_rad, diff_rad, refl_rad, glob_rad):
if not output:
continue
exp = '{out} = if({inp} > 0, 1, 0)'.format(out=output + suffix +
binaryTmpName,
inp=output + suffix)
grass.mapcalc(exp=exp, overwrite=core.overwrite())
grass.run_command(
'g.rename',
raster=[output + suffix + binaryTmpName, output + suffix],
overwrite=True)
def run_r_sun(elevation, aspect, slope, day, time,
linke, linke_value, albedo, albedo_value,
horizon_basename, horizon_step,
beam_rad, diff_rad, refl_rad, glob_rad,
incidout, suffix, binary, binaryTmpName):
params = {}
if linke:
params.update({'linke': linke})
if linke_value:
params.update({'linke_value': linke_value})
if albedo:
params.update({'albedo': albedo})
if albedo_value:
params.update({'albedo_value': albedo_value})
if beam_rad:
params.update({'beam_rad': beam_rad + suffix})
if diff_rad:
params.update({'diff_rad': diff_rad + suffix})
if refl_rad:
params.update({'refl_rad': refl_rad + suffix})
if glob_rad:
params.update({'glob_rad': glob_rad + suffix})
if incidout:
params.update({'incidout': incidout + suffix})
if horizon_basename and horizon_step:
params.update({'horizon_basename': horizon_basename})
params.update({'horizon_step': horizon_step})
if is_grass_7():
grass.run_command('r.sun', elevation=elevation, aspect=aspect,
slope=slope, day=day, time=time,
overwrite=core.overwrite(), quiet=True,
**params)
else:
grass.run_command('r.sun', elevin=elevation, aspin=aspect,
slopein=slope, day=day, time=time,
overwrite=core.overwrite(), quiet=True,
**params)
if binary:
for output in (beam_rad, diff_rad, refl_rad, glob_rad):
if not output:
continue
exp='{out} = if({inp} > 0, 1, 0)'.format(out=output + suffix + binaryTmpName,
inp=output + suffix)
grass.mapcalc(exp=exp, overwrite=core.overwrite())
grass.run_command('g.rename', raster = [output + suffix + binaryTmpName,
output + suffix],
overwrite=True)
def run_r_shaded_relief(
elevation_input,
shades_basename,
altitude,
azimuth,
z_exaggeration,
scale,
units,
suffix,
):
params = {}
if units:
params.update({"units": units})
grass.run_command(
"r.relief",
input=elevation_input,
output=shades_basename + suffix,
azimuth=azimuth,
zscale=z_exaggeration,
scale=scale,
altitude=altitude,
overwrite=core.overwrite(),
quiet=True,
**params,
)
def import_files(directory, pattern):
maps = []
if pattern:
from glob import glob
files = glob('{dir}{sep}{pat}'.format(
dir=directory, sep=os.path.sep, pat=pattern)
)
else:
files = map(lambda x: os.path.join(directory, x),
os.listdir(directory)
)
start = time.time()
import_module = Module('v.in.ascii', separator='space', z=3, flags='tbz',
overwrite=overwrite(), quiet=True, run_=False)
try:
for f in files:
basename = os.path.basename(f)
mapname = os.path.splitext(basename)[0]
maps.append(mapname)
message("Importing <{}>...".format(f))
import_task = deepcopy(import_module)
queue.put(import_task(input=f, output=mapname))
queue.wait()
except CalledModuleError:
return sys.exit(1)
if not maps:
fatal("No input files found")
message("Import finished in {:.0f} sec".format(time.time() - start))
return maps
def check_file(filename, map_type, sep):
with open(filename) as names_file:
for line in names_file:
line = line.strip()
names = line.split(sep)
if len(names) != 2:
max_display_chars_for_line = 10
if len(line) > max_display_chars_for_line:
line = line[:max_display_chars_for_line]
gcore.fatal(
_("Cannot parse line <{line}> using separator"
" <{sep}> in file <{file}>. Nothing renamed.").format(
line=line, sep=sep, file=filename))
if not map_exists(names[0], type=map_type):
gcore.fatal(
_("Map <{name}> (type <{type}>) does not exist"
" in the current Mapset."
" Nothing renamed. Note that maps in other Mapsets cannot"
" be renamed, however they can be copied.").format(
name=names[0], type=map_type))
if not gcore.overwrite() and map_exists(names[1], type=map_type):
gcore.fatal(
_("Map <{name}> (type <{type}>) already exists."
" Nothing renamed."
" Use overwrite flag if you want to overwrite"
" the existing maps.").format(name=names[0],
type=map_type))
def main(opts, flgs):
ow = overwrite()
CCEXTR = 'cable_crane_extraction = if(yield>0 && slope>'+opts['slp_min_cc']+' && slope<='+opts['slp_max_cc']+' && extr_dist<'+opts['dist_max_cc']+', 1)'
FWEXTR = 'forwarder_extraction = if(yield>0 && slope<='+opts['slp_max_fw']+' && management==1 && (roughness==0 || roughness==1 || roughness==99999) && extr_dist<'+opts['dist_max_fw']+', 1)'
OEXTR = 'other_extraction = if(yield>0 && slope<='+opts['slp_max_cop']+' && management==2 && (roughness==0 || roughness==1 || roughness==99999) && extr_dist<'+opts['dist_max_cop']+', 1)'
EHF = 'technical_bioenergyHF = technical_surface*(if(management==1 && treatment==1 || management==1 && treatment==99999, yield_pix*'+opts['energy_tops_hf']+', if(management==1 && treatment==2, yield_pix *'+opts['energy_tops_hf']+' + yield_pix * '+opts['energy_cormometric_vol_hf']+')))'
ECC = 'technical_bioenergyC = technical_surface*(if(management == 2, yield_pix*'+opts['energy_tops_cop']+'))'
run_command("r.param.scale", overwrite=ow,
input=opts['dtm'], output="morphometric_features",
size=3, param="feature")
run_command("r.slope.aspect", overwrite=ow,
elevation=opts['dtm'], slope="slope_deg")
run_command("r.mapcalc", overwrite=ow,
expression='pix_cross = ((ewres()+nsres())/2)/ cos(slope_deg)')
run_command("r.null", map="yield_pix1", null=0)
run_command("r.null", map="lakes", null=0)
run_command("r.null", map="rivers", null=0)
run_command("r.null", map="morphometric_features", null=0)
#morphometric_features==6 -> peaks
run_command("r.mapcalc", overwrite=ow,
expression='frict_surf_extr = if(morphometric_features==6, 99999) + if(rivers>=1 || lakes>=1, 99999) + if(yield_pix1<=0, 99999) + pix_cross')
run_command("r.cost", overwrite=ow,
input="frict_surf_extr", output="extr_dist",
stop_points="forest", start_rast="forest_roads",
max_cost=1500)
run_command("r.slope.aspect", flags="a", overwrite=ow,
elevation=opts['dtm'], slope="slope", format="percent")
run_command("r.mapcalc", overwrite=ow,expression=CCEXTR)
run_command("r.mapcalc", overwrite=ow,
expression=FWEXTR)
run_command("r.mapcalc", overwrite=ow,
expression=OEXTR)
run_command("r.null", map="cable_crane_extraction", null=0)
run_command("r.null", map="forwarder_extraction", null=0)
run_command("r.null", map="other_extraction", null=0)
run_command("r.mapcalc", overwrite=ow,
expression='technical_surface = cable_crane_extraction + forwarder_extraction + other_extraction')
run_command("r.statistics", overwrite=ow,
base="compartment", cover="technical_surface", method="sum",
output="techn_pix_comp")
run_command("r.mapcalc", overwrite=ow,
expression='yield_pix2 = yield/(technical_surface*@techn_pix_comp)')
run_command("r.null", map="yield_pix2", null=0)
run_command("r.mapcalc", overwrite=ow,
expression=YPIX % (1 if flgs['u'] else 0, 0 if flgs['u'] else 1,))
run_command("r.mapcalc", overwrite=ow,expression=EHF)
run_command("r.mapcalc", overwrite=ow,
expression=ECC)
run_command("r.mapcalc", overwrite=ow,
expression='technical_bioenergy = (technical_bioenergyHF + technical_bioenergyC)')
def get_new_points(points, lines, output, maxdist=50):
skipped = []
ovwr = gcore.overwrite()
msgr = get_msgr()
points, pmset = points.split('@') if '@' in points else (points, '')
lines, lmset = lines.split('@') if '@' in lines else (lines, '')
with VectorTopo(points, mapset=pmset, mode='r') as pts:
cols = pts.table.columns.items() if pts.table else None
with VectorTopo(lines, mapset=lmset, mode='r') as lns:
with VectorTopo(output, mode='w', tab_cols=cols,
overwrite=ovwr) as out:
for pnt in pts:
line = lns.find['by_point'].geo(pnt, maxdist=maxdist)
if line is None:
msg = ("Not found any line in the radius of %.2f "
"for the point with cat: %d. The point "
"will be skipped!")
msgr.warning(msg % (maxdist, pnt.cat))
skipped.append(pnt.cat)
continue
# find the new point
newpnt, dist, _, _ = line.distance(pnt)
# get the attributes
attrs = (None
if pnt.attrs is None else pnt.attrs.values()[1:])
# write the new point in the new vector map
out.write(newpnt, attrs)
# save the changes on the output table
out.table.conn.commit()
def main(opts, flgs):
TMPVECT = []
DEBUG = True if flgs['d'] else False
atexit.register(cleanup, vector=TMPVECT, debug=DEBUG)
# check input maps
plant = [
opts['plant_column_discharge'], opts['plant_column_elevup'],
opts['plant_column_elevdown'], opts['plant_column_point_id'],
opts['plant_column_plant_id'], opts['plant_column_power'],
opts['plant_column_stream_id']
]
ovwr = overwrite()
try:
plnt = check_required_columns(opts['plant'], int(opts['plant_layer']),
plant, 'plant')
except ParameterError as exc:
exception2error(exc)
return
if not opts['output_point']:
output_point = 'tmp_output_point'
TMPVECT.append(output_point)
else:
output_point = opts['output_point']
plnt = conv_segpoints(opts['plant'], output_point)
el, mset = (opts['elevation'].split('@') if '@' in opts['elevation'] else
(opts['elevation'], ''))
elev = RasterRow(name=el, mapset=mset)
elev.open('r')
plnt.open('r')
plants, skipped = read_plants(plnt,
elev=elev,
restitution='restitution',
intake='intake',
ckind_label='kind_label',
cdischarge='discharge',
celevation='elevation',
cid_point='cat',
cid_plant='plant_id')
plnt.close()
# contour options
resolution = float(opts['resolution']) if opts['resolution'] else None
write_structures(plants,
opts['output_struct'],
elev,
ndigits=int(opts['ndigits']),
resolution=resolution,
contour=opts['contour'],
overwrite=ovwr)
elev.close()
def main():
input = options['input']
layer = options['layer']
format = options['format']
dsn = options['dsn']
table = options['table']
if format.lower() == 'dbf':
format = "ESRI_Shapefile"
if format.lower() == 'csv':
olayer = basename(dsn, 'csv')
else:
olayer = None
#is there a simpler way of testing for --overwrite?
dbffile = input + '.dbf'
if os.path.exists(dbffile) and not grass.overwrite():
grass.fatal(_("File <%s> already exists") % dbffile)
if olayer:
if grass.run_command('v.out.ogr',
quiet=True,
input=input,
layer=layer,
dsn=dsn,
format=format,
type='point,line,area',
olayer=olayer) != 0:
sys.exit(1)
else:
if grass.run_command('v.out.ogr',
quiet=True,
input=input,
layer=layer,
dsn=dsn,
format=format,
type='point,line,area') != 0:
sys.exit(1)
if format == "ESRI_Shapefile":
exts = ['shp', 'shx', 'prj']
if dsn.endswith('.dbf'):
outname = basename(dsn, 'dbf')
for ext in exts:
try_remove("%s.%s" % (outname, ext))
outname += '.dbf'
else:
for ext in exts:
try_remove(os.path.join(dsn, "%s.%s" % (input, ext)))
outname = os.path.join(dsn, input + ".dbf")
elif format.lower() == 'csv':
outname = dsn + '.csv'
else:
outname = input
grass.message(_("Exported table <%s>") % outname)
def main():
input = options['input']
layer = options['layer']
format = options['format']
output = options['output']
table = options['table']
if format.lower() == 'dbf':
format = "ESRI_Shapefile"
if format.lower() == 'csv':
olayer = basename(output, 'csv')
else:
olayer = None
#is there a simpler way of testing for --overwrite?
dbffile = input + '.dbf'
if os.path.exists(dbffile) and not grass.overwrite():
grass.fatal(_("File <%s> already exists") % dbffile)
if olayer:
try:
grass.run_command('v.out.ogr', quiet=True, input=input, layer=layer,
output=output,
format=format, type='point,line,area',
olayer=olayer)
except CalledModuleError:
grass.fatal(_("Module <%s> failed") % 'v.out.ogr')
else:
try:
grass.run_command('v.out.ogr', quiet=True, input=input,
layer=layer, output=output,
format=format, type='point,line,area')
except CalledModuleError:
grass.fatal(_("Module <%s> failed") % 'v.out.ogr')
if format == "ESRI_Shapefile":
exts = ['shp', 'shx', 'prj']
if output.endswith('.dbf'):
outname = basename(output, 'dbf')
for ext in exts:
try_remove("%s.%s" % (outname, ext))
outname += '.dbf'
else:
for ext in exts:
try_remove(os.path.join(output, "%s.%s" % (input, ext)))
outname = os.path.join(output, input + ".dbf")
elif format.lower() == 'csv':
outname = output + '.csv'
else:
outname = input
grass.message(_("Exported table <%s>") % outname)
def main():
input = options['input']
layer = options['layer']
format = options['format']
output = options['output']
table = options['table']
if format.lower() == 'dbf':
format = "ESRI_Shapefile"
if format.lower() == 'csv':
olayer = basename(output, 'csv')
else:
olayer = None
# is there a simpler way of testing for --overwrite?
dbffile = input + '.dbf'
if os.path.exists(dbffile) and not gcore.overwrite():
gcore.fatal(_("File <%s> already exists") % dbffile)
if olayer:
try:
gcore.run_command('v.out.ogr', quiet=True, input=input,
layer=layer, output=output, format=format,
type='point,line,area', olayer=olayer)
except CalledModuleError:
gcore.fatal(_("Module <%s> failed") % 'v.out.ogr')
else:
try:
gcore.run_command('v.out.ogr', quiet=True, input=input,
layer=layer, output=output,
format=format, type='point,line,area')
except CalledModuleError:
gcore.fatal(_("Module <%s> failed") % 'v.out.ogr')
if format == "ESRI_Shapefile":
exts = ['shp', 'shx', 'prj']
if output.endswith('.dbf'):
outname = basename(output, 'dbf')
for ext in exts:
try_remove("%s.%s" % (outname, ext))
outname += '.dbf'
else:
for ext in exts:
try_remove(os.path.join(output, "%s.%s" % (input, ext)))
outname = os.path.join(output, input + ".dbf")
elif format.lower() == 'csv':
outname = output + '.csv'
else:
outname = input
gcore.message(_("Exported table <%s>") % outname)
def run_r_sun(elevation, aspect, slope, latitude, longitude, linke,
linke_value, albedo, albedo_value, horizon_basename,
horizon_step, solar_constant, day, step, beam_rad, diff_rad,
refl_rad, glob_rad, insol_time, suffix, flags):
'''
Execute r.sun using the provided input options. Except for the required
parameters, the function updates the list of optional/selected parameters
to instruct for user requested inputs and outputs.
Optional inputs:
- latitude
- longitude
- linke OR single linke value
- albedo OR single albedo value
- horizon maps
'''
params = {}
if beam_rad:
params.update({'beam_rad': beam_rad + suffix})
if diff_rad:
params.update({'diff_rad': diff_rad + suffix})
if refl_rad:
params.update({'refl_rad': refl_rad + suffix})
if glob_rad:
params.update({'glob_rad': glob_rad + suffix})
if insol_time:
params.update({'insol_time': insol_time + suffix})
if linke:
params.update({'linke': linke})
if linke_value:
params.update({'linke_value': linke_value})
if albedo:
params.update({'albedo': albedo})
if albedo_value:
params.update({'albedo_value': albedo_value})
if horizon_basename and horizon_step:
params.update({'horizon_basename': horizon_basename})
params.update({'horizon_step': horizon_step})
if solar_constant is not None:
params.update({'solar_constant': solar_constant})
if flags:
params.update({'flags': flags})
grass.run_command('r.sun',
elevation=elevation,
aspect=aspect,
slope=slope,
day=day,
step=step,
overwrite=core.overwrite(),
quiet=True,
**params)
def main():
options, flags = gcore.parser()
print options, flags
gisenv = gcore.gisenv()
if 'MONITOR' in gisenv:
cmd_file = gisenv['MONITOR_{monitor}_CMDFILE'.format(monitor=gisenv['MONITOR'].upper())]
d_cmd = 'd.to.rast'
for param, val in options.iteritems():
if val:
d_cmd += " {param}={val}".format(param=param, val=val)
if gcore.overwrite():
d_cmd += ' --overwrite'
with open(cmd_file, "a") as file_:
file_.write(d_cmd)
else:
gcore.fatal(_("No graphics device selected. Use d.mon to select graphics device."))
def main():
options, flags = gcore.parser()
gisenv = gcore.gisenv()
if 'MONITOR' in gisenv:
cmd_file = gcore.parse_command('d.mon', flags='g')['cmd']
d_cmd = 'd.to.rast'
for param, val in options.items():
if val:
d_cmd += " {param}={val}".format(param=param, val=val)
if gcore.overwrite():
d_cmd += ' --overwrite'
with open(cmd_file, "a") as file_:
file_.write(d_cmd)
else:
gcore.fatal(
_("No graphics device selected. Use d.mon to select graphics device."
))
def main():
options, flags = gcore.parser()
gisenv = gcore.gisenv()
if "MONITOR" in gisenv:
cmd_file = gcore.parse_command("d.mon", flags="g")["cmd"]
d_cmd = "d.to.rast"
for param, val in options.items():
if val:
d_cmd += " {param}={val}".format(param=param, val=val)
if gcore.overwrite():
d_cmd += " --overwrite"
with open(cmd_file, "a") as file_:
file_.write(d_cmd)
else:
gcore.fatal(
_("No graphics device selected. Use d.mon to select graphics device.")
)
def main():
input = options['input']
format = options['format']
dsn = options['dsn']
table = options['table']
if format.lower() == 'dbf':
format = "ESRI_Shapefile"
if format.lower() == 'csv':
olayer = grass.basename(dsn, 'csv')
else:
olayer = None
#is there a simpler way of testing for --overwrite?
dbffile = input + '.dbf'
if os.path.exists(dbffile) and not grass.overwrite():
grass.fatal(_("File <%s> already exists") % dbffile)
if olayer:
if grass.run_command('v.out.ogr', quiet = True, input = input, dsn = dsn,
format = format, type = 'point', olayer = olayer) != 0:
sys.exit(1)
else:
if grass.run_command('v.out.ogr', quiet = True, input = input, dsn = dsn,
format = format, type = 'point') != 0:
sys.exit(1)
if format == "ESRI_Shapefile":
exts = ['shp', 'shx', 'prj']
if dsn.endswith('.dbf'):
outname = grass.basename(dsn, 'dbf')
for ext in exts:
grass.try_remove("%s.%s" % (outname, ext))
outname += '.dbf'
else:
for ext in exts:
grass.try_remove(os.path.join(dsn, "%s.%s" % (input, ext)))
outname = os.path.join(dsn, input + ".dbf")
elif format.lower() == 'csv':
outname = dsn + '.csv'
else:
outname = input
grass.message(_("Exported table <%s>") % outname)
def p_statement_assign(self, t):
"""
statement : NAME EQUALS expression
| NAME EQUALS name
| NAME EQUALS paren_name
"""
# We remove the invalid vector name from the list
if t[3] in self.names:
self.names.pop(t[3])
# We rename the resulting vector map
if self.debug:
print("g.rename vector=%s,%s" % (t[3], t[1]))
if self.run:
m = mod.Module('g.rename', vector=(t[3], t[1]),
overwrite=grass.overwrite(), run_=False)
self.cmdlist.add_cmd(m)
self.remove_intermediate_vector_maps()
def main():
options, flags = gcore.parser()
print options, flags
gisenv = gcore.gisenv()
if 'MONITOR' in gisenv:
cmd_file = gisenv['MONITOR_{monitor}_CMDFILE'.format(
monitor=gisenv['MONITOR'].upper())]
d_cmd = 'd.to.rast'
for param, val in options.iteritems():
if val:
d_cmd += " {param}={val}".format(param=param, val=val)
if gcore.overwrite():
d_cmd += ' --overwrite'
with open(cmd_file, "a") as file_:
file_.write(d_cmd)
else:
gcore.fatal(
_("No graphics device selected. Use d.mon to select graphics device."
))
def main():
magnitude = options['magnitude']
direction = options['direction']
divergence = options['output']
global TMP, CLEANUP
tmp_name = 'tmp_divergence_' + str(os.getpid())
qsx = tmp_name + "qsx"
qsy = tmp_name + "qsy"
qsx_dx = tmp_name + "qsx_dx"
qsy_dy = tmp_name + "qsy_dy"
TMP.extend([qsx, qsy, qsx_dx, qsy_dy])
# checks if there are already some maps
old_maps = temp_maps_exist()
if old_maps:
if not gcore.overwrite():
CLEANUP = False
gcore.fatal(
_("You have to first check overwrite flag or remove"
" the following maps:\n"
"names}").format(names=','.join(old_maps)))
else:
gcore.warning(
_("The following maps will be overwritten: {names}").format(
names=','.join(old_maps)))
try:
grast.mapcalc(exp="{qsx}={mag} * cos({direct})".format(
qsx=qsx, mag=magnitude, direct=direction))
grast.mapcalc(exp="{qsy}={mag} * sin({direct})".format(
qsy=qsy, mag=magnitude, direct=direction))
gcore.run_command('r.slope.aspect', elevation=qsx, dx=qsx_dx)
gcore.run_command('r.slope.aspect', elevation=qsy, dy=qsy_dy)
grast.mapcalc(exp="{div}={qsx_dx} + {qsy_dy}".format(
div=divergence, qsx_dx=qsx_dx, qsy_dy=qsy_dy))
except CalledModuleError:
gcore.fatal(
_("r.divergence failed, check errors above. Please report this problem to developers."
))
return 1
grast.raster_history(divergence)
return 0
def make_new_table(vct, tname, cols=COLS, force=None):
"""Check/remove/create a new table"""
msgr = get_msgr()
force = overwrite() if force is None else force
create_link = True
# make a new table
table = Table(tname, vct.table.conn)
if table.exist():
if any([table.name == l.table_name for l in vct.dblinks]):
create_link = False
msg = _("Table <%s> already exist and will be removed.")
msgr.warning(msg % table.name)
table.drop(force=force)
table.create(cols)
# fill the new table with the segment cats
slct = vct.table.filters.select(vct.table.key)
cur = vct.table.execute(slct.get_sql())
table.insert(((cat[0], None) for cat in cur), many=True)
table.conn.commit()
return table, create_link
def create_dmt_tiles(maps, res, rst_nprocs, offset_multiplier=10):
offset=res * offset_multiplier
start = time.time()
region_module = Module('g.region', n='n+{}'.format(offset), s='s-{}'.format(offset),
e='e+{}'.format(offset), w='w-{}'.format(offset),
quiet=True)
rst_module = Module('v.surf.rst', nprocs=rst_nprocs,
overwrite=overwrite(), quiet=True, run_=False)
try:
for mapname in maps:
message("Interpolating <{}>...".format(mapname))
region_task = deepcopy(region_module)
rst_task = deepcopy(rst_module)
mm = MultiModule([region_task(vector=mapname),
rst_task(input=mapname, elevation=mapname)],
sync=False, set_temp_region=True)
queue.put(mm)
queue.wait()
except CalledModuleError:
return sys.exit(1)
message("Interpolation finished in {:.0f} min".format((time.time() - start) / 60.))
def main(opts, flgs):
pid = os.getpid()
pat = "tmprgreen_%i_*" % pid
atexit.register(cleanup,
pattern=pat,
debug=False)
# check or generate raster map from rules files
ecovalues = ['landvalue', 'tributes', 'stumpage', 'rotation', 'age',
'min_exc', 'max_exc']
(lan, tri, stu, rot, age,
excmin, excmax) = check_raster_or_landuse(opts, ecovalues)
upper = opts['upper'] if opts['upper'] else ('tmprgreen_%i_upper' % pid)
comp = opts['compensation'] if opts['compensation'] else ('tmprgreen_%i_compensation' % pid)
exc = opts['excavation'] if opts['excavation'] else ('tmprgreen_%i_excavation' % pid)
vlayer = int(opts['struct_layer'])
plant, mset = (opts['plant'].split('@') if '@' in opts['plant'] else (opts['plant'], ''))
struct, mset = (opts['struct'].split('@') if '@' in opts['struct'] else (opts['struct'], ''))
# read common scalar parameters
irate = float(opts['interest_rate'])
life = float(opts['life'])
width = float(opts['width'])
depth = float(opts['depth'])
slim = float(opts['slope_limit'])
overw = overwrite()
# RASTERS
# Start computing the raster map of the costs
# Upper value
upper_value(upper, stu, lan, rot, age, irate, overw)
# Compensation raster costs
compensation_cost(comp, lan, tri, upper,
irate, float(opts['gamma_comp']), life, width, overw)
# Excavation raster costs
excavation_cost(exc, excmin, excmax, opts['slope'],
slim, width, depth, overw)
# TODO: extra cost when crossing roads and rivers are missing
# VECTOR
# add columns with costs from rasters
# add compensation costs
v.rast_stats(map=struct, layer=vlayer, flags='c',
raster=comp, column_prefix='comp_cost', method='sum')
# add excavation costs
v.rast_stats(map=struct, layer=vlayer, flags='c',
raster=exc, column_prefix='exc_cost', method='sum')
# add elecro-mechanical costs
electromechanical_cost(struct,
power=opts['struct_column_power'],
head=opts['struct_column_head'],
gamma=float(opts['gamma_em']),
alpha=float(opts['alpha_em']),
beta=float(opts['beta_em']),
const=float(opts['const_em']),
vlayer=vlayer, cname='em_cost',
ctype='double precision',
overwrite=overw)
# add linear cost for pipeline
linear_cost(vname=struct, cname='lin_pipe_cost',
alpha=float(opts['lc_pipe']), vlayer=vlayer,
ctype='double precision', overwrite=overw)
# add linear for for electroline
get_electro_length(opts)
linear_cost(vname=struct, cname='lin_electro_cost',
alpha=float(opts['lc_electro']), length='electro_length',
vlayer=vlayer, ctype='double precision', overwrite=overw)
# Compensation raster costs for electroline
comp = (opts['compensation']+'el' if
opts['compensation']
else ('tmprgreen_%i_compensation_el' % pid))
exc = (opts['excavation']+'el'
if opts['excavation']
else ('tmprgreen_%i_excavation_el' % pid))
compensation_cost(comp, lan, tri, upper,
irate, float(opts['gamma_comp']), life, 0.6, overw)
# Excavation raster costs for electroline
excavation_cost(exc, excmin, excmax, opts['slope'],
slim, 0.6, 0.6, overw)
# add excavation cost and compensation cost for electroline
elines = (opts['elines'] if opts['elines']
else ('tmprgreen_%i_elines' % pid))
v.rast_stats(map=elines, layer=vlayer, flags='c',
raster=comp, column_prefix='comp_cost', method='sum')
# add excavation costs
v.rast_stats(map=elines, layer=vlayer, flags='c',
raster=exc, column_prefix='exc_cost', method='sum')
write2struct(elines, opts)
xcost = "{cname} = {alpha} * {em}"
# add power station costs
vcolcalc(vname=struct, vlayer=vlayer,
ctype='double precision',
expr=xcost.format(cname='station_cost', em='em_cost',
alpha=opts['alpha_station']))
# add inlet costs
vcolcalc(vname=struct, vlayer=vlayer,
ctype='double precision', notfinitesubstitute=0.,
expr=xcost.format(cname='inlet_cost', em='em_cost',
alpha=opts['alpha_inlet']))
# add total inlet costs
# TODO: to be check to avoid to count cost more than one time I have moltiplied by 0.5
tot = ('tot_cost = (comp_cost_sum + em_cost + el_comp_exc +'
'lin_pipe_cost + lin_electro_cost + '
'station_cost + inlet_cost + {grid}*0.5) * '
'(1 + {general} + {hindrances})')
vcolcalc(vname=struct, vlayer=vlayer,
ctype='double precision', notfinitesubstitute=0.,
expr=tot.format(grid=opts['grid'], general=opts['general'],
hindrances=opts['hindrances']))
# TODO: produce a new vector map (output), with the conduct + penstock in
# a unique line and sum the costs grouping by intake_id and side
# SELECT {key} FROM {tname}
#FIXME: intake_id and discharge can have different names
group_by(struct, opts['output_struct'],
isolate=['intake_id', opts['struct_column_id'],
opts['struct_column_side'], opts['struct_column_power'],
opts['struct_column_head'], 'discharge'],
aggregate=['tot_cost', ],
function='sum',
group_by=['intake_id', opts['struct_column_side']])
"""
where these values (3871.2256 and -0.45) are coming from?
import numpy as np
from scipy import stats
power= np.array([50., 100., 200., 400., 600., 1000., 5000.])
maint = np.array([707., 443., 389., 261., 209., 163., 88.])
plt.plot(np.log(power), np.log(maint))
plt.show()
slope, intercept, r_value, p_value, std_err = stats.linregress(np.log(power), np.log(maint))
#slope -0.45000431409701719
#intercept 8.2613264284076049
np.exp(intercept) * power ** slope
"""
# maint = "{cname} = {alpha} * {power} ** (1 + {beta}) + {const}"
maint = "{cname} = {cost_per_kW} * {power} * {alpha} + {const}"
# compute yearly maintenance costs
vcolcalc(vname=opts['output_struct'], vlayer=vlayer,
ctype='double precision', notfinitesubstitute=0.,
expr=maint.format(cname='maintenance',
cost_per_kW=opts['cost_maintenance_per_kw'],
alpha=opts['alpha_maintenance'],
power=opts['struct_column_power'],
beta=opts['beta_maintenance'],
const=opts['const_maintenance']))
# compute yearly revenues
rev = "{cname} = {eta} * {power} * {eprice} * {ophours} + {const}"
vcolcalc(vname=opts['output_struct'], vlayer=vlayer,
ctype='double precision', notfinitesubstitute=0.,
expr=rev.format(cname='revenue',
eta=opts['eta'],
power=opts['struct_column_power'],
eprice=opts['energy_price'],
ophours=opts['operative_hours'],
const=opts['const_revenue']))
# compute the Net Present Value
npv = "{cname} = {gamma} * ({revenue} - {maintenance}) - {tot}"
gamma_npv = get_gamma_NPV(irate, life)
vcolcalc(vname=opts['output_struct'], vlayer=vlayer,
ctype='double precision', notfinitesubstitute=0.,
expr=npv.format(cname='NPV',
gamma=gamma_npv,
revenue='revenue',
maintenance='maintenance',
tot='tot_cost'))
economic2segment(economic=opts['output_struct'], segment=plant,
basename=opts['plant_basename'],
eco_layer=1, seg_layer=int(opts['plant_layer']),
eco_pid=opts['struct_column_id'],
seg_pid=opts['plant_column_id'],
function=max_NPV,
exclude=['intake_id', 'side', 'power',
'gross_head', 'discharge'])
vec = VectorTopo(opts['output_struct'])
vec.open('rw')
vec.table.columns.add('max_NPV','VARCHAR(3)')
list_intakeid=list(set(vec.table.execute('SELECT intake_id FROM %s' %vec.table.name).fetchall()))
for i in range(0,len(list_intakeid)):
vec.rewind()
list_npv=list(vec.table.execute('SELECT NPV FROM %s WHERE intake_id=%i;' % (vec.table.name, list_intakeid[i][0])).fetchall())
npvmax=max(list_npv)[0]
for line in vec:
if line.attrs['intake_id'] == list_intakeid[i][0]:
if line.attrs['NPV'] == npvmax:
line.attrs['max_NPV']='yes'
else:
line.attrs['max_NPV']='no'
vec.table.conn.commit()
vec.close()
def main():
input = options["input"]
output = options["output"]
fs = options["fs"]
proj_in = options["proj_input"]
proj_out = options["proj_output"]
ll_in = flags["i"]
ll_out = flags["o"]
decimal = flags["d"]
copy_input = flags["e"]
include_header = flags["c"]
#### check for cs2cs
if not grass.find_program("cs2cs"):
grass.fatal(_("cs2cs program not found, install PROJ.4 first: http://proj.maptools.org"))
#### check for overenthusiasm
if proj_in and ll_in:
grass.fatal(_("Choose only one input parameter method"))
if proj_out and ll_out:
grass.fatal(_("Choose only one output parameter method"))
if ll_in and ll_out:
grass.fatal(_("Choise only one auto-projection parameter method"))
if output and not grass.overwrite() and os.path.exists(output):
grass.fatal(_("Output file already exists"))
#### parse field separator
# FIXME: input_x,y needs to split on multiple whitespace between them
if fs == ",":
ifs = ofs = ","
else:
try:
ifs, ofs = fs.split(",")
except ValueError:
ifs = ofs = fs
ifs = ifs.lower()
ofs = ofs.lower()
if ifs in ("space", "tab"):
ifs = " "
elif ifs == "comma":
ifs = ","
else:
if len(ifs) > 1:
grass.warning(_("Invalid field separator, using '%s'") % ifs[0])
try:
ifs = ifs[0]
except IndexError:
grass.fatal(_("Invalid field separator '%s'") % ifs)
if ofs.lower() == "space":
ofs = " "
elif ofs.lower() == "tab":
ofs = "\t"
elif ofs.lower() == "comma":
ofs = ","
else:
if len(ofs) > 1:
grass.warning(_("Invalid field separator, using '%s'") % ofs[0])
try:
ofs = ofs[0]
except IndexError:
grass.fatal(_("Invalid field separator '%s'") % ifs)
#### set up projection params
s = grass.read_command("g.proj", flags="j")
kv = grass.parse_key_val(s)
if "XY location" in kv["+proj"] and (ll_in or ll_out):
grass.fatal(_("Unable to project to or from a XY location"))
in_proj = None
if ll_in:
in_proj = "+proj=longlat +datum=WGS84"
grass.verbose("Assuming LL WGS84 as input, current projection as output ")
if ll_out:
in_proj = grass.read_command("g.proj", flags="jf")
if proj_in:
in_proj = proj_in
if not in_proj:
grass.verbose("Assuming current location as input")
in_proj = grass.read_command("g.proj", flags="jf")
in_proj = in_proj.strip()
grass.verbose("Input parameters: '%s'" % in_proj)
out_proj = None
if ll_out:
out_proj = "+proj=longlat +datum=WGS84"
grass.verbose("Assuming current projection as input, LL WGS84 as output ")
if ll_in:
out_proj = grass.read_command("g.proj", flags="jf")
if proj_out:
out_proj = proj_out
if not out_proj:
grass.fatal(_("Missing output projection parameters "))
out_proj = out_proj.strip()
grass.verbose("Output parameters: '%s'" % out_proj)
#### set up input file
if input == "-":
infile = None
inf = sys.stdin
else:
infile = input
if not os.path.exists(infile):
grass.fatal(_("Unable to read input data"))
inf = file(infile)
grass.debug("input file=[%s]" % infile)
#### set up output file
if not output:
outfile = None
outf = sys.stdout
else:
outfile = output
outf = open(outfile, "w")
grass.debug("output file=[%s]" % outfile)
#### set up output style
if not decimal:
outfmt = ["-w5"]
else:
outfmt = ["-f", "%.8f"]
if not copy_input:
copyinp = []
else:
copyinp = ["-E"]
#### do the conversion
# Convert cs2cs DMS format to GRASS DMS format:
# cs2cs | sed -e 's/d/:/g' -e "s/'/:/g" -e 's/"//g'
cmd = ["cs2cs"] + copyinp + outfmt + in_proj.split() + ["+to"] + out_proj.split()
p = grass.Popen(cmd, stdin=grass.PIPE, stdout=grass.PIPE)
tr = TrThread(ifs, inf, p.stdin)
tr.start()
if not copy_input:
if include_header:
outf.write("x%sy%sz\n" % (ofs, ofs))
for line in p.stdout:
xy, z = line.split(" ", 1)
x, y = xy.split("\t")
outf.write("%s%s%s%s%s\n" % (x.strip(), ofs, y.strip(), ofs, z.strip()))
else:
if include_header:
outf.write("input_x%sinput_y%sx%sy%sz\n" % (ofs, ofs, ofs, ofs))
for line in p.stdout:
inXYZ, x, rest = line.split("\t")
inX, inY = inXYZ.split(" ")[:2]
y, z = rest.split(" ", 1)
outf.write(
"%s%s%s%s%s%s%s%s%s\n" % (inX.strip(), ofs, inY.strip(), ofs, x.strip(), ofs, y.strip(), ofs, z.strip())
)
p.wait()
if p.returncode != 0:
grass.warning(_("Projection transform probably failed, please investigate"))
def main(opts, flgs):
ow = overwrite()
output = opts["output_prefix"]
management = opts["management"]
treatment = opts["treatment"]
# ouput variables
rec_bioenergyHF = output + "_rec_bioenergyHF"
rec_bioenergyC = output + "_rec_bioenergyC"
rec_bioenergy = output + "_rec_bioenergy"
# input variables
pot_HF = opts["hfmap"]
pot_C = opts["cmap"]
rivers = opts["hydro"]
buffer_hydro = int(opts["buffer_hydro"])
zone_less = opts["zone_less"]
check_var = 0
# pdb.set_trace()
# check if the raster of rivers is present with a buffer inserted
if buffer_hydro > 0 and rivers == "":
print(
"if the river buffer is greater than zero, the raster map of rivers is required"
)
return
# recovery of the series of raster constraint maps
restr_map = opts["restrictions"].split(",")
# start the query string
expr_map = "constraint="
# check if at least 1 constraint map is inserted
if opts["restrictions"] != "":
check_var = 1
count_map = 0
# cycle with composition of the query string with all the constraint maps
for mapr_ in restr_map:
mapr1 = string.split(mapr_, "@")
mapr = mapr1[0]
if count_map == 0:
expr_map += "(" + mapr
convert_bool = mapr + "=" + mapr + ">0"
run_command("r.mapcalc", overwrite=1, expression=convert_bool)
run_command("r.null", map=mapr, null=0)
else:
expr_map += "||" + mapr
convert_bool = mapr + "=" + mapr + ">0"
run_command("r.mapcalc", overwrite=1, expression=convert_bool)
run_command("r.null", map=mapr, null=0)
count_map += 1
expr_map += ")"
# if the river buffer is inserted add calculate the buffer and
# add the buffer to the constraint map
if buffer_hydro > 0:
run_command("r.null", map=rivers, null=0)
run_command(
"r.buffer",
overwrite=ow,
input=rivers,
output="rivers_buffer",
distances=buffer_hydro,
flags="z",
)
run_command("r.null", map="rivers_buffer", null=0)
if check_var == 1:
expr_map += "|| (rivers || rivers_buffer)"
else:
expr_map += "rivers || rivers_buffer"
check_var = 1
if zone_less != "":
check_var = 1
if check_var == 0:
print("Error: At least one constraint map must be inserted")
return
else:
# if at least one contraint is inserted process the potential map
run_command(
"r.mapcalc", overwrite=ow, expression=rec_bioenergyHF + "=" + pot_HF
)
run_command("r.mapcalc", overwrite=ow, expression=rec_bioenergyC + "=" + pot_C)
run_command("r.mapcalc", overwrite=ow, expression=expr_map)
run_command("r.mapcalc", overwrite=ow, expression="constraint=constraint<1")
run_command("r.null", map="constraint", null=0)
constr_HF = rec_bioenergyHF + "=" + rec_bioenergyHF + "*constraint"
constr_C = rec_bioenergyC + "=" + rec_bioenergyC + "*constraint"
run_command("r.mapcalc", overwrite=ow, expression=constr_HF)
run_command("r.mapcalc", overwrite=ow, expression=constr_C)
if zone_less != "":
run_command(
"r.mapcalc",
overwrite=ow,
expression="wood_pix=(" + zone_less + "/((ewres()*nsres())*10000))",
)
WHF = (
"wood_energyHF= if("
+ management
+ "==1 && "
+ treatment
+ "==1 || "
+ management
+ " == 1 && "
+ treatment
+ "==99999, wood_pix*%f, if("
+ management
+ "==1 && "
+ treatment
+ "==2, wood_pix*%f + wood_pix*%f))"
)
WCC = (
"wood_energyC = if("
+ management
+ "==2, wood_pix*"
+ opts["energy_tops_cop"]
+ ")"
)
run_command(
"r.mapcalc",
overwrite=ow,
expression=WHF
% tuple(
map(
float,
(
opts["energy_tops_hf"],
opts["energy_tops_hf"],
opts["energy_cormometric_vol_hf"],
),
)
),
)
run_command("r.mapcalc", overwrite=ow, expression=WCC)
run_command("r.null", map="wood_energyHF", null=0)
run_command("r.null", map="wood_energyC", null=0)
limit_HF = rec_bioenergyHF + "=" + rec_bioenergyHF + "-wood_energyHF"
limit_C = rec_bioenergyC + "=" + rec_bioenergyC + "-wood_energyC"
run_command("r.mapcalc", overwrite=ow, expression=limit_HF)
run_command("r.mapcalc", overwrite=ow, expression=limit_C)
RECOT = rec_bioenergy + " = (" + rec_bioenergyHF + " + " + rec_bioenergyC + ")"
run_command("r.mapcalc", overwrite=ow, expression=RECOT)
with RasterRow(rec_bioenergy) as pT:
T = np.array(pT)
print(
"Resulted maps: "
+ output
+ "_rec_bioenergyHF, "
+ output
+ "_rec_bioenergyC, "
+ output
+ "_rec_bioenergy"
)
print("Total bioenergy stimated (Mwh): %.2f" % np.nansum(T))
def main():
coords = options['coordinates']
input = options['input']
output = options['output']
fs = options['separator']
proj_in = options['proj_in']
proj_out = options['proj_out']
ll_in = flags['i']
ll_out = flags['o']
decimal = flags['d']
copy_input = flags['e']
include_header = flags['c']
# check for cs2cs
if not gcore.find_program('cs2cs'):
gcore.fatal(
_("cs2cs program not found, install PROJ.4 first: \
http://proj.maptools.org"))
# check for overenthusiasm
if proj_in and ll_in:
gcore.fatal(_("Choose only one input parameter method"))
if proj_out and ll_out:
gcore.fatal(_("Choose only one output parameter method"))
if ll_in and ll_out:
gcore.fatal(_("Choose only one auto-projection parameter method"))
if output and not gcore.overwrite() and os.path.exists(output):
gcore.fatal(_("Output file already exists"))
if not coords and not input:
gcore.fatal(_("One of <coordinates> and <input> must be given"))
if coords and input:
gcore.fatal(
_("Options <coordinates> and <input> are mutually exclusive"))
# parse field separator
# FIXME: input_x,y needs to split on multiple whitespace between them
if fs == ',':
ifs = ofs = ','
else:
try:
ifs, ofs = fs.split(',')
except ValueError:
ifs = ofs = fs
ifs = separator(ifs)
ofs = separator(ofs)
# set up projection params
s = gcore.read_command("g.proj", flags='j')
kv = parse_key_val(s)
if "XY location" in kv['+proj'] and (ll_in or ll_out):
gcore.fatal(_("Unable to project to or from a XY location"))
in_proj = None
if ll_in:
in_proj = "+proj=longlat +datum=WGS84"
gcore.verbose(
"Assuming LL WGS84 as input, current projection as output ")
if ll_out:
in_proj = gcore.read_command('g.proj', flags='jf')
if proj_in:
if '+' in proj_in:
in_proj = proj_in
else:
gcore.fatal(_("Invalid PROJ.4 input specification"))
if not in_proj:
gcore.verbose("Assuming current location as input")
in_proj = gcore.read_command('g.proj', flags='jf')
in_proj = in_proj.strip()
gcore.verbose("Input parameters: '%s'" % in_proj)
out_proj = None
if ll_out:
out_proj = "+proj=longlat +datum=WGS84"
gcore.verbose(
"Assuming current projection as input, LL WGS84 as output ")
if ll_in:
out_proj = gcore.read_command('g.proj', flags='jf')
if proj_out:
if '+' in proj_out:
out_proj = proj_out
else:
gcore.fatal(_("Invalid PROJ.4 output specification"))
if not out_proj:
gcore.fatal(_("Missing output projection parameters "))
out_proj = out_proj.strip()
gcore.verbose("Output parameters: '%s'" % out_proj)
# set up input file
if coords:
x, y = coords.split(',')
tmpfile = gcore.tempfile()
fd = open(tmpfile, "w")
fd.write("%s%s%s\n" % (x, ifs, y))
fd.close()
inf = file(tmpfile)
else:
if input == '-':
infile = None
inf = sys.stdin
else:
infile = input
if not os.path.exists(infile):
gcore.fatal(_("Unable to read input data"))
inf = file(infile)
gcore.debug("input file=[%s]" % infile)
# set up output file
if not output:
outfile = None
outf = sys.stdout
else:
outfile = output
outf = open(outfile, 'w')
gcore.debug("output file=[%s]" % outfile)
# set up output style
if not decimal:
outfmt = ["-w5"]
else:
outfmt = ["-f", "%.8f"]
if not copy_input:
copyinp = []
else:
copyinp = ["-E"]
# do the conversion
# Convert cs2cs DMS format to GRASS DMS format:
# cs2cs | sed -e 's/d/:/g' -e "s/'/:/g" -e 's/"//g'
cmd = ['cs2cs'] + copyinp + outfmt + \
in_proj.split() + ['+to'] + out_proj.split()
p = gcore.Popen(cmd, stdin=gcore.PIPE, stdout=gcore.PIPE)
tr = TrThread(ifs, inf, p.stdin)
tr.start()
if not copy_input:
if include_header:
outf.write("x%sy%sz\n" % (ofs, ofs))
for line in p.stdout:
try:
xy, z = line.split(' ', 1)
x, y = xy.split('\t')
except ValueError:
gcore.fatal(line)
outf.write('%s%s%s%s%s\n' %
(x.strip(), ofs, y.strip(), ofs, z.strip()))
else:
if include_header:
outf.write("input_x%sinput_y%sx%sy%sz\n" % (ofs, ofs, ofs, ofs))
for line in p.stdout:
inXYZ, x, rest = line.split('\t')
inX, inY = inXYZ.split(' ')[:2]
y, z = rest.split(' ', 1)
outf.write('%s%s%s%s%s%s%s%s%s\n' %
(inX.strip(), ofs, inY.strip(), ofs, x.strip(), ofs,
y.strip(), ofs, z.strip()))
p.wait()
if p.returncode != 0:
gcore.warning(
_("Projection transform probably failed, please investigate"))
def run_r_sun(elevation, aspect, slope, day, time, civil_time, linke,
linke_value, albedo, albedo_value, coeff_bh, coeff_dh, lat,
long_, beam_rad, diff_rad, refl_rad, glob_rad, incidout, suffix,
binary, tmpName, time_step, distance_step, solar_constant,
flags):
params = {}
if linke:
params.update({'linke': linke})
if linke_value:
params.update({'linke_value': linke_value})
if albedo:
params.update({'albedo': albedo})
if albedo_value:
params.update({'albedo_value': albedo_value})
if coeff_bh:
params.update({'coeff_bh': coeff_bh})
if coeff_dh:
params.update({'coeff_dh': coeff_dh})
if lat:
params.update({'lat': lat})
if long_:
params.update({'long': long_})
if beam_rad:
params.update({'beam_rad': beam_rad + suffix})
if diff_rad:
params.update({'diff_rad': diff_rad + suffix})
if refl_rad:
params.update({'refl_rad': refl_rad + suffix})
if glob_rad:
params.update({'glob_rad': glob_rad + suffix})
if incidout:
params.update({'incidout': incidout + suffix})
if flags:
params.update({'flags': flags})
if civil_time is not None:
params.update({'civil_time': civil_time})
if distance_step is not None:
params.update({'distance_step': distance_step})
if solar_constant is not None:
params.update({'solar_constant': solar_constant})
if is_grass_7():
grass.run_command('r.sun',
elevation=elevation,
aspect=aspect,
slope=slope,
day=day,
time=time,
overwrite=core.overwrite(),
quiet=True,
**params)
else:
grass.run_command('r.sun',
elevin=elevation,
aspin=aspect,
slopein=slope,
day=day,
time=time,
overwrite=core.overwrite(),
quiet=True,
**params)
if binary:
for output in (beam_rad, diff_rad, refl_rad, glob_rad):
if not output:
continue
exp = '{out} = if({inp} > 0, 1, 0)'.format(out=output + suffix +
tmpName,
inp=output + suffix)
grass.mapcalc(exp=exp, overwrite=core.overwrite())
grass.run_command(
'g.rename',
raster=[output + suffix + tmpName, output + suffix],
quiet=True,
overwrite=True)
if time_step:
for output in (beam_rad, diff_rad, refl_rad, glob_rad):
if not output:
continue
exp = '{out} = {inp} * {ts}'.format(inp=output + suffix,
ts=time_step,
out=output + suffix + tmpName)
grass.mapcalc(exp=exp, overwrite=core.overwrite())
grass.run_command(
'g.rename',
raster=[output + suffix + tmpName, output + suffix],
overwrite=True,
quiet=True)
def main():
options, flags = grass.parser()
elevation_input = options['input']
pca_shade_output = options['output']
altitude = float(options['altitude'])
number_of_azimuths = int(options['nazimuths'])
z_exaggeration = float(options['zscale'])
scale = float(options['scale'])
units = options['units']
shades_basename = options['shades_basename']
pca_basename = pca_basename_user = options['pca_shades_basename']
nprocs = int(options['nprocs'])
full_circle = 360
# let's use floats here and leave the consequences to the user
smallest_angle = float(full_circle) / number_of_azimuths
azimuths = list(frange(0, full_circle, smallest_angle))
if not shades_basename:
shades_basename = create_tmp_map_name('shade')
MREMOVE.append(shades_basename)
if not pca_basename:
pca_basename = pca_shade_output + '_pca'
pca_maps = [
pca_basename + '.' + str(i) for i in range(1, number_of_azimuths + 1)
]
if not pca_basename_user:
REMOVE.extend(pca_maps)
# here we check all the posible
if not grass.overwrite():
check_map_names(shades_basename,
grass.gisenv()['MAPSET'],
suffixes=azimuths)
check_map_names(pca_basename,
grass.gisenv()['MAPSET'],
suffixes=range(1, number_of_azimuths))
grass.info(_("Running r.relief in a loop..."))
count = 0
# Parallel processing
proc_list = []
proc_count = 0
suffixes = []
all_suffixes = []
core.percent(0, number_of_azimuths, 1)
for azimuth in azimuths:
count += 1
core.percent(count, number_of_azimuths, 10)
suffix = '_' + str(azimuth)
proc_list.append(
Process(target=run_r_shaded_relief,
args=(elevation_input, shades_basename, altitude, azimuth,
z_exaggeration, scale, units, suffix)))
proc_list[proc_count].start()
proc_count += 1
suffixes.append(suffix)
all_suffixes.append(suffix)
if proc_count == nprocs or proc_count == number_of_azimuths \
or count == number_of_azimuths:
proc_count = 0
exitcodes = 0
for proc in proc_list:
proc.join()
exitcodes += proc.exitcode
if exitcodes != 0:
core.fatal(_("Error during r.relief computation"))
# Empty process list
proc_list = []
suffixes = []
# FIXME: how percent really works?
# core.percent(1, 1, 1)
shade_maps = [shades_basename + suf for suf in all_suffixes]
grass.info(_("Running r.pca..."))
# not quiet=True to get percents
grass.run_command('i.pca',
input=shade_maps,
output=pca_basename,
overwrite=core.overwrite())
grass.info(
_("Creating RGB composite from "
"PC1 (red), PC2 (green), PC3 (blue) ..."))
grass.run_command('r.composite',
red=pca_maps[0],
green=pca_maps[1],
blue=pca_maps[2],
output=pca_shade_output,
overwrite=core.overwrite(),
quiet=True)
grass.raster_history(pca_shade_output)
if pca_basename_user:
set_color_table(pca_maps, map_=shade_maps[0])
def main():
indb = options['database']
prefix = options['basename']
env = grass.gisenv()
#fix sqlite3 db field string multibyte character problem
sys.setdefaultencoding('utf-8')
# check if 3d or not
if flags['z']:
d3 = 'z'
else:
d3 = ''
owrite = grass.overwrite()
# check if location it is latlong
if grass.locn_is_latlong():
locn = True
else:
locn = False
# connection to sqlite geopaparazzi database
import sqlite3
conn = sqlite3.connect(indb)
curs = conn.cursor()
# if it is not a latlong location create a latlong location on the fly
if not locn:
# create new location and move to it creating new gisrc file
new_loc = basename(grass.tempfile(create=False))
new_loc_name = 'geopaparazzi_%s' % new_loc
grass.create_location(dbase=env['GISDBASE'], epsg='4326',
location=new_loc_name,
desc='Temporary location for v.in.geopaparazzi')
grc = os.getenv('GISRC')
shutil.copyfile(grc, grc + '.old')
newrc = open(grc, 'w')
newrc.write('GISDBASE: %s\n' % env['GISDBASE'])
newrc.write('LOCATION_NAME: %s\n' % new_loc_name)
newrc.write('MAPSET: PERMANENT\n')
newrc.write('GRASS_GUI: text\n')
newrc.close()
grass.run_command('db.connect', flags="d", quiet=True)
# load bookmarks
if flags['b']:
# check if elements in bookmarks table are more the 0
if checkEle(curs, 'bookmarks') != 0:
bookname = prefix + '_book'
pois = importGeom(bookname, 'bookmarks', curs, owrite, '')
sql = 'CREATE TABLE %s (cat int, text text)' % bookname
grass.write_command('db.execute', input='-', stdin=sql)
# select attributes
sql = "select text from bookmarks order by _id"
allattri = returnClear(curs, sql)
# add values using insert statement
idcat = 1
for row in allattri:
values = "%d,'%s'" % (idcat, str(row))
sql = "insert into %s values(%s)" % (bookname, values)
grass.write_command('db.execute', input='-', stdin=sql)
idcat += 1
# at the end connect table to vector
grass.run_command('v.db.connect', map=bookname,
table=bookname, quiet=True)
else:
grass.warning(_("No bookmarks found, escape them"))
# load images
if flags['i']:
# check if elements in images table are more the 0
if checkEle(curs, 'images') != 0:
imagename = prefix + '_image'
pois = importGeom(imagename, 'images', curs, owrite, d3)
sql = 'CREATE TABLE %s (cat int, azim int, ' % imagename
sql += 'path text, ts text, text text)'
grass.write_command('db.execute', input='-', stdin=sql)
# select attributes
sql = "select azim, path, ts, text from images order by _id"
allattri = returnAll(curs, sql)
# add values using insert statement
idcat = 1
for row in allattri:
values = "%d,'%d','%s','%s','%s'" % (idcat, row[0],
str(row[1]), str(row[2]),
str(row[3]))
sql = "insert into %s values(%s)" % (imagename, values)
grass.write_command('db.execute', input='-', stdin=sql)
idcat += 1
# at the end connect table to vector
grass.run_command('v.db.connect', map=imagename, table=imagename,
quiet=True)
else:
grass.warning(_("No images found, escape them"))
# if tracks or nodes should be imported create a connection with sqlite3
# load notes
if flags['n']:
# check if elements in notes table are more the 0
if checkEle(curs, 'notes') != 0:
# select each categories
categories = returnClear(curs, "select cat from notes group by cat")
# for each category
for cat in categories:
# select lat, lon for create point layer
catname = prefix + '_notes_' + cat
pois = importGeom(catname, 'notes', curs, owrite, d3, cat)
# select form to understand the number
forms = returnClear(curs, "select _id from notes where cat = '%s' "
"and form is not null order by _id" % cat)
# if number of form is different from 0 and number of point
# remove the vector because some form it is different
if len(forms) != 0 and len(forms) != len(pois):
grass.run_command('g.remove', flags='f', type='vector', name=catname, quiet=True)
grass.warning(_("Vector %s not imported because number"
" of points and form is different"))
# if form it's 0 there is no form
elif len(forms) == 0:
# create table without form
sql = 'CREATE TABLE %s (cat int, ts text, ' % catname
sql += 'text text, geopap_cat text)'
grass.write_command('db.execute', input='-', stdin=sql)
# select attributes
sql = "select ts, text, cat from notes where "\
"cat='%s' order by _id" % cat
allattri = returnAll(curs, sql)
# add values using insert statement
idcat = 1
for row in allattri:
values = "%d,'%s','%s','%s'" % (idcat, str(row[0]),
str(row[1]),
str(row[2]))
sql = "insert into %s values(%s)" % (catname, values)
grass.write_command('db.execute', input='-', stdin=sql)
idcat += 1
# at the end connect table to vector
grass.run_command('v.db.connect', map=catname,
table=catname, quiet=True)
# create table with form
else:
# select all the attribute
sql = "select ts, text, cat, form from notes where "\
"cat='%s' order by _id" % cat
allattri = returnAll(curs, sql)
# return string of form's categories too create table
keys = returnFormKeys(allattri)
sql = 'CREATE TABLE %s (cat int, ts text, ' % catname
sql += 'text text, geopap_cat text %s)' % keys
grass.write_command('db.execute', input='-', stdin=sql)
# it's for the number of categories
idcat = 1
# for each feature insert value
for row in allattri:
values = "%d,'%s','%s','%s'," % (idcat, str(row[0]),
str(row[1]),
str(row[2]))
values += returnFormValues(row[3])
sql = "insert into %s values(%s)" % (catname, values)
grass.write_command('db.execute', input='-', stdin=sql)
idcat += 1
# at the end connect table with vector
grass.run_command('v.db.connect', map=catname,
table=catname, quiet=True)
else:
grass.warning(_("No notes found, escape them"))
# load tracks
if flags['t']:
# check if elements in bookmarks table are more the 0
if checkEle(curs, 'gpslogs') != 0:
tracksname = prefix + '_tracks'
# define string for insert data at the end
tracks = ''
# return ids of tracks
ids = returnClear(curs, "select _id from gpslogs")
# for each track
for i in ids:
# select all the points coordinates
tsel = "select lon, lat"
if flags['z']:
tsel += ", altim"
tsel += " from gpslog_data where logid=%s order by _id" % i
trackpoints = returnAll(curs, tsel)
wpoi = '\n'.join(['|'.join([str(col) for col in row]) for row in trackpoints])
tracks += "%s\n" % wpoi
if flags['z']:
tracks += 'NaN|NaN|Nan\n'
else:
tracks += 'NaN|Nan\n'
# import lines
try:
grass.write_command('v.in.lines', flags=d3, input='-',
out=tracksname, stdin=tracks,
overwrite=owrite, quiet=True)
except CalledModuleError:
grass.fatal(_("Error importing %s" % tracksname))
# create table for line
sql = 'CREATE TABLE %s (cat int, startts text, ' % tracksname
sql += 'endts text, text text, color text, width int)'
grass.write_command('db.execute', input='-', stdin=sql)
sql = "select logid, startts, endts, text, color, width from" \
" gpslogs, gpslogsproperties where gpslogs._id=" \
"gpslogsproperties.logid"
# return attributes
allattri = returnAll(curs, sql)
# for each line insert attribute
for row in allattri:
values = "%d,'%s','%s','%s','%s',%d" % (row[0], str(row[1]),
str(row[2]),
str(row[3]),
str(row[4]), row[5])
sql = "insert into %s values(%s)" % (tracksname, values)
grass.write_command('db.execute', input='-', stdin=sql)
# at the end connect map with table
grass.run_command('v.db.connect', map=tracksname,
table=tracksname, quiet=True)
else:
grass.warning(_("No tracks found, escape them"))
# if location it's not latlong reproject it
if not locn:
# copy restore the original location
shutil.copyfile(grc + '.old', grc)
# reproject bookmarks
if flags['b'] and checkEle(curs, 'bookmarks') != 0:
grass.run_command('v.proj', quiet=True, input=bookname,
location='geopaparazzi_%s' % new_loc,
mapset='PERMANENT')
# reproject images
if flags['i'] and checkEle(curs, 'images') != 0:
grass.run_command('v.proj', quiet=True, input=imagename,
location='geopaparazzi_%s' % new_loc,
mapset='PERMANENT')
# reproject notes
if flags['n'] and checkEle(curs, 'notes') != 0:
for cat in categories:
catname = prefix + '_node_' + cat
grass.run_command('v.proj', quiet=True, input=catname,
location='geopaparazzi_%s' % new_loc,
mapset='PERMANENT')
# reproject track
if flags['t'] and checkEle(curs, 'gpslogs') != 0:
grass.run_command('v.proj', quiet=True, input=tracksname,
location='geopaparazzi_%s' % new_loc,
mapset='PERMANENT')
def main():
elev = options['input']
output = options['output']
n_dir = int(options['ndir'])
global TMP_NAME, CLEANUP
if options['basename']:
TMP_NAME = options['basename']
CLEANUP = False
colorized_output = options['colorized_output']
colorize_color = options['color_table']
if colorized_output:
color_raster_tmp = TMP_NAME + "_color_raster"
else:
color_raster_tmp = None
color_raster_type = options['color_source']
color_input = options['color_input']
if color_raster_type == 'color_input' and not color_input:
gcore.fatal(_("Provide raster name in color_input option"))
if color_raster_type != 'color_input' and color_input:
gcore.fatal(
_("The option color_input is not needed"
" when not using it as source for color"))
# this would be needed only when no value would allowed
if not color_raster_type and color_input:
color_raster_type = 'color_input' # enable for convenience
if color_raster_type == 'aspect' \
and colorize_color \
and colorize_color not in ['default', 'aspectcolr']:
gcore.warning(
_("Using possibly inappropriate color table <{}>"
" for aspect".format(colorize_color)))
horizon_step = 360. / n_dir
msgr = get_msgr()
# checks if there are already some maps
old_maps = _get_horizon_maps()
if old_maps:
if not gcore.overwrite():
CLEANUP = False
msgr.fatal(
_("You have to first check overwrite flag or remove"
" the following maps:\n"
"{names}").format(names=','.join(old_maps)))
else:
msgr.warning(
_("The following maps will be overwritten: {names}").format(
names=','.join(old_maps)))
if not gcore.overwrite() and color_raster_tmp:
check_map_name(color_raster_tmp)
try:
params = {}
if options['maxdistance']:
params['maxdistance'] = options['maxdistance']
gcore.run_command('r.horizon',
elevation=elev,
step=horizon_step,
output=TMP_NAME,
flags='d',
**params)
new_maps = _get_horizon_maps()
if flags['o']:
msgr.message(_("Computing openness ..."))
expr = '{out} = 1 - (sin({first}) '.format(first=new_maps[0],
out=output)
for horizon in new_maps[1:]:
expr += '+ sin({name}) '.format(name=horizon)
expr += ") / {n}.".format(n=len(new_maps))
else:
msgr.message(_("Computing skyview factor ..."))
expr = '{out} = 1 - (sin( if({first} < 0, 0, {first}) ) '.format(
first=new_maps[0], out=output)
for horizon in new_maps[1:]:
expr += '+ sin( if({name} < 0, 0, {name}) ) '.format(
name=horizon)
expr += ") / {n}.".format(n=len(new_maps))
grast.mapcalc(exp=expr)
gcore.run_command('r.colors', map=output, color='grey')
except CalledModuleError:
msgr.fatal(
_("r.horizon failed to compute horizon elevation "
"angle maps. Please report this problem to developers."))
return 1
if colorized_output:
if color_raster_type == 'slope':
gcore.run_command('r.slope.aspect',
elevation=elev,
slope=color_raster_tmp)
elif color_raster_type == 'aspect':
gcore.run_command('r.slope.aspect',
elevation=elev,
aspect=color_raster_tmp)
elif color_raster_type == 'dxy':
gcore.run_command('r.slope.aspect',
elevation=elev,
dxy=color_raster_tmp)
elif color_raster_type == 'color_input':
color_raster_tmp = color_input
else:
color_raster_tmp = elev
# don't modify user's color table for inputs
if colorize_color \
and color_raster_type not in ['input', 'color_input']:
rcolors_flags = ''
if flags['n']:
rcolors_flags += 'n'
gcore.run_command('r.colors',
map=color_raster_tmp,
color=colorize_color,
flags=rcolors_flags)
gcore.run_command('r.shade',
shade=output,
color=color_raster_tmp,
output=colorized_output)
grast.raster_history(colorized_output)
grast.raster_history(output)
return 0
def main():
options, flags = gcore.parser()
aspect = options['aspect']
speed = options['speed']
probability = options['probability']
if options['particle_base']:
particle_base = options['particle_base'] + '_'
else:
particle_base = None
if options['particles']:
particles = options['particles']
min_size = float(options['min_size'])
max_size = float(options['max_size'])
comet_length = int(options['comet_length'])
else:
particles = min_size = max_size = comet_length = None
try:
total_time = int(options['total_time'])
step = int(options['step'])
age = int(options['age'])
count = int(options['count'])
except ValueError:
gcore.fatal(_("Parameter should be integer"))
gcore.use_temp_region()
# create aspect in x and y direction
aspect_x = 'aspect_x_' + str(os.getpid())
aspect_y = 'aspect_y_' + str(os.getpid())
xshift_tmp = 'xshift_tmp_' + str(os.getpid())
yshift_tmp = 'yshift_tmp_' + str(os.getpid())
TMP_RAST.append(aspect_x)
TMP_RAST.append(aspect_y)
grast.mapcalc(exp="{aspect_x} = cos({aspect})".format(aspect_x=aspect_x, aspect=aspect))
grast.mapcalc(exp="{aspect_y} = sin({aspect})".format(aspect_y=aspect_y, aspect=aspect))
grast.mapcalc(exp="{xshift} = {aspect_x}*{speed}*{t}".format(xshift=xshift_tmp, t=step, speed=speed,
aspect_x=aspect_x), overwrite=True)
grast.mapcalc(exp="{yshift} = {aspect_y}*{speed}*{t}".format(yshift=yshift_tmp, t=step, speed=speed,
aspect_y=aspect_y), overwrite=True)
# initialize
vector_tmp1 = 'vector_tmp1_' + str(os.getpid())
vector_tmp2 = 'vector_tmp2_' + str(os.getpid())
vector_tmp3 = 'vector_tmp3_' + str(os.getpid())
vector_region = 'vector_region_' + str(os.getpid())
TMP_VECT.extend([vector_tmp1, vector_tmp2, vector_tmp3, vector_region])
random_tmp = 'random_tmp_' + str(os.getpid())
TMP_RAST.extend([xshift_tmp, yshift_tmp, random_tmp])
gcore.run_command('v.in.region', output=vector_region, type='area')
loop = 0
vector_1 = particle_base + "{0:03d}".format(loop)
generate_points(name=vector_1, probability_map=probability, count=count)
grast.mapcalc(exp="{random} = int(rand(1, {maxt}))".format(random=random_tmp, maxt=age + 1))
gcore.run_command('v.what.rast', map=vector_1, raster=random_tmp, column='t')
write_vect_history('v.particles', options, flags, vector_1)
vector_names = [vector_1, ]
for time in range(0, total_time + step, step):
vector_1 = particle_base + "{0:03d}".format(loop)
vector_2 = particle_base + "{0:03d}".format(loop + 1)
vector_names.append(vector_2)
gcore.run_command('v.what.rast', map=vector_1, raster=xshift_tmp, column='xshift')
gcore.run_command('v.what.rast', map=vector_1, raster=yshift_tmp, column='yshift')
gcore.run_command('v.transform', layer=1, input=vector_1, output=vector_2,
columns='xshift:xshift,yshift:yshift', quiet=True)
# increase age
gcore.info("Increasing age...")
sql = 'UPDATE {table} SET t=t+1;'.format(table=vector_2)
gcore.run_command('db.execute', sql=sql)
# remove old points
gcore.info("Removing old points...")
gcore.run_command('v.select', overwrite=True, ainput=vector_2, atype='point',
binput=vector_region, btype='area', operator='within', output=vector_tmp1)
gcore.run_command('v.extract', input=vector_tmp1, layer=1, type='point',
where="t <= " + str(age) + " AND xshift IS NOT NULL", output=vector_tmp2, overwrite=True)
# generate new points
gcore.info("Generating new points...")
count_to_generate = count - gvect.vector_info(vector_tmp2)['points']
if count_to_generate > 0:
generate_points(name=vector_tmp3, probability_map=probability,
count=count_to_generate, overwrite=True)
gcore.info("Patchig new and old points...")
gcore.run_command('v.patch', flags='e', input=[vector_tmp2, vector_tmp3],
output=vector_2, overwrite=True)
sql = 'UPDATE {table} SET t={t} WHERE t IS NULL;'.format(table=vector_2, t=0)
gcore.run_command('db.execute', sql=sql)
write_vect_history('v.particles', options, flags, vector_2)
loop += 1
# Make sure the temporal database exists
tgis.init()
tgis.open_new_space_time_dataset(particle_base[:-1], type='stvds',
temporaltype='relative',
title="title", descr='desc',
semantic='mean', dbif=None,
overwrite=gcore.overwrite())
# TODO: we must start from 1 because there is a bug in register_maps_in_space_time_dataset
tgis.register_maps_in_space_time_dataset(
type='vect', name=particle_base[:-1], maps=','.join(vector_names),
start=str(1), end=None, unit='seconds', increment=step,
interval=False, dbif=None)
# create one vector map with multiple layers
fd, path = tempfile.mkstemp(text=True)
tmpfile = open(path, 'w')
k = 0
for vector in vector_names:
k += 1
layers = [x for x in range(k - comet_length + 1, k + 1) if x > 0]
categories = list(range(len(layers), 0, -1))
text = ''
for layer, cat in zip(layers, categories):
text += '{l} {c}\n'.format(l=layer, c=cat)
coords = gcore.read_command('v.to.db', flags='p', quiet=True, map=vector,
type='point', option='coor', separator=" ").strip()
for coord in coords.split('\n'):
coord = coord.split()
tmpfile.write('P 1 {n_cat}\n{x} {y}\n'.format(n_cat=len(categories), x=coord[1], y=coord[2]))
tmpfile.write(text)
tmpfile.close()
gcore.run_command('v.in.ascii', flags='n', overwrite=True, input=path, output=particles,
format='standard', separator=" ")
os.close(fd)
os.remove(path)
k = 0
sql = []
sizes = get_sizes(max_size, min_size, comet_length)
temporal_maps = []
for vector in vector_names:
k += 1
table = 't' + str(k)
gcore.run_command('v.db.addtable', map=particles, table=table, layer=k,
column="width double precision")
temporal_maps.append(particles + ':' + str(k))
for i in range(comet_length):
sql.append("UPDATE {table} SET width={w:.1f} WHERE cat={c}".format(table=table,
w=sizes[i][1], c=sizes[i][0]))
gcore.write_command('db.execute', input='-', stdin=';\n'.join(sql))
tgis.open_new_space_time_dataset(particles, type='stvds',
temporaltype='relative',
title="title", descr='desc',
semantic='mean', dbif=None,
overwrite=True)
# TODO: we must start from 1 because there is a bug in register_maps_in_space_time_dataset
tgis.register_maps_in_space_time_dataset(
type='vect', name=particles, maps=','.join(temporal_maps),
start=str(1), end=None, unit='seconds', increment=step,
interval=False, dbif=None)
write_vect_history('v.particles', options, flags, particles)
def main(opt, flg):
# import functions which depend on sklearn only after parser run
from ml_functions import (balance, explorer_clsfiers, run_classifier,
optimize_training, explore_SVC, plot_grid)
from features import importances, tocsv
msgr = get_msgr()
indexes = None
vect = opt['vector']
vtraining = opt['vtraining'] if opt['vtraining'] else None
scaler, decmp = None, None
vlayer = opt['vlayer'] if opt['vlayer'] else vect + '_stats'
tlayer = opt['tlayer'] if opt['tlayer'] else vect + '_training'
rlayer = opt['rlayer'] if opt['rlayer'] else vect + '_results'
labels = extract_classes(vtraining, 1)
pprint(labels)
if opt['scalar']:
scapar = opt['scalar'].split(',')
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler(with_mean='with_mean' in scapar,
with_std='with_std' in scapar)
if opt['decomposition']:
dec, params = (opt['decomposition'].split('|')
if '|' in opt['decomposition']
else (opt['decomposition'], ''))
kwargs = ({k: v for k, v in (p.split('=') for p in params.split(','))}
if params else {})
load_decompositions()
decmp = DECMP[dec](**kwargs)
# if training extract training
if vtraining and flg['e']:
msgr.message("Extract training from: <%s> to <%s>." % (vtraining, vect))
extract_training(vect, vtraining, tlayer)
flg['n'] = True
if flg['n']:
msgr.message("Save arrays to npy files.")
save2npy(vect, vlayer, tlayer,
fcats=opt['npy_cats'], fcols=opt['npy_cols'],
fdata=opt['npy_data'], findx=opt['npy_index'],
fclss=opt['npy_tclasses'], ftdata=opt['npy_tdata'])
# define the classifiers to use/test
if opt['pyclassifiers'] and opt['pyvar']:
# import classifiers to use
mycls = imp.load_source("mycls", opt['pyclassifiers'])
classifiers = getattr(mycls, opt['pyvar'])
else:
from ml_classifiers import CLASSIFIERS
classifiers = CLASSIFIERS
# Append the SVC classifier
if opt['svc_c'] and opt['svc_gamma']:
from sklearn.svm import SVC
svc = {'name': 'SVC', 'classifier': SVC,
'kwargs': {'C': float(opt['svc_c']),
'gamma': float(opt['svc_gamma']),
'kernel': opt['svc_kernel']}}
classifiers.append(svc)
# extract classifiers from pyindx
if opt['pyindx']:
indexes = [i for i in get_indexes(opt['pyindx'])]
classifiers = [classifiers[i] for i in indexes]
num = int(opt['n_training']) if opt['n_training'] else None
# load fron npy files
Xt = np.load(opt['npy_tdata'])
Yt = np.load(opt['npy_tclasses'])
cols = np.load(opt['npy_cols'])
# Define rules to substitute NaN, Inf, posInf, negInf values
rules = {}
for key in ('nan', 'inf', 'neginf', 'posinf'):
if opt[key]:
rules[key] = get_rules(opt[key])
pprint(rules)
# Substitute (skip cat column)
Xt, rules_vals = substitute(Xt, rules, cols[1:])
Xtoriginal = Xt
# scale the data
if scaler:
msgr.message("Scaling the training data set.")
scaler.fit(Xt, Yt)
Xt = scaler.transform(Xt)
# decompose data
if decmp:
msgr.message("Decomposing the training data set.")
decmp.fit(Xt)
Xt = decmp.transform(Xt)
# Feature importances with forests of trees
if flg['f']:
np.save('training_transformed.npy', Xt)
importances(Xt, Yt, cols[1:],
csv=opt['imp_csv'], img=opt['imp_fig'],
# default parameters to save the matplotlib figure
**dict(dpi=300, transparent=False, bbox_inches='tight'))
# optimize the training set
if flg['o']:
ind_optimize = (int(opt['pyindx_optimize']) if opt['pyindx_optimize']
else 0)
cls = classifiers[ind_optimize]
msgr.message("Find the optimum training set.")
best, Xbt, Ybt = optimize_training(cls, Xt, Yt,
labels, #{v: k for k, v in labels.items()},
scaler, decmp,
num=num, maxiterations=1000)
msg = " - save the optimum training data set to: %s."
msgr.message(msg % opt['npy_btdata'])
np.save(opt['npy_btdata'], Xbt)
msg = " - save the optimum training classes set to: %s."
msgr.message(msg % opt['npy_btclasses'])
np.save(opt['npy_btclasses'], Ybt)
# balance the data
if flg['b']:
msg = "Balancing the training data set, each class have <%d> samples."
msgr.message(msg % num)
Xbt, Ybt = balance(Xt, Yt, num)
else:
if not flg['o']:
Xbt = (np.load(opt['npy_btdata'])
if os.path.isfile(opt['npy_btdata']) else Xt)
Ybt = (np.load(opt['npy_btclasses'])
if os.path.isfile(opt['npy_btclasses']) else Yt)
# scale the data
if scaler:
msgr.message("Scaling the training data set.")
scaler.fit(Xbt, Ybt)
Xt = scaler.transform(Xt)
Xbt = scaler.transform(Xbt)
if flg['d']:
C_range = [float(c) for c in opt['svc_c_range'].split(',') if c]
gamma_range = [float(g) for g in opt['svc_gamma_range'].split(',') if g]
kernel_range = [str(s) for s in opt['svc_kernel_range'].split(',') if s]
poly_range = [int(i) for i in opt['svc_poly_range'].split(',') if i]
allkwargs = dict(C=C_range, gamma=gamma_range,
kernel=kernel_range, degree=poly_range)
kwargs = {}
for k in allkwargs:
if allkwargs[k]:
kwargs[k] = allkwargs[k]
msgr.message("Exploring the SVC domain.")
grid = explore_SVC(Xbt, Ybt, n_folds=5, n_jobs=int(opt['svc_n_jobs']),
**kwargs)
import pickle
krnlstr = '_'.join(s for s in opt['svc_kernel_range'].split(',') if s)
pkl = open('grid%s.pkl' % krnlstr, 'w')
pickle.dump(grid, pkl)
pkl.close()
# pkl = open('grid.pkl', 'r')
# grid = pickle.load(pkl)
# pkl.close()
plot_grid(grid, save=opt['svc_img'])
# test the accuracy of different classifiers
if flg['t']:
# test different classifiers
msgr.message("Exploring different classifiers.")
msgr.message("cls_id cls_name mean max min std")
res = explorer_clsfiers(classifiers, Xt, Yt, labels=labels,
indexes=indexes, n_folds=5,
bv=flg['v'], extra=flg['x'])
# TODO: sort(order=...) is working only in the terminal, why?
#res.sort(order='mean')
with open(opt['csv_test_cls'], 'w') as csv:
csv.write(tocsv(res))
if flg['c']:
# classify
data = np.load(opt['npy_data'])
indx = np.load(opt['npy_index'])
# Substitute using column values
data, dummy = substitute(data, rules, cols[1:])
Xt = data[indx]
if scaler:
msgr.message("Scaling the training data set.")
scaler.fit(Xt, Yt)
Xt = scaler.transform(Xt)
msgr.message("Scaling the whole data set.")
data = scaler.transform(data)
if decmp:
msgr.message("Decomposing the training data set.")
decmp.fit(Xt)
Xt = decmp.transform(Xt)
msgr.message("Decompose the whole data set.")
data = decmp.transform(data)
cats = np.load(opt['npy_cats'])
np.save('data_filled_scaled.npy', data)
tcols = []
for cls in classifiers:
report = (open(opt['report_class'], "w")
if opt['report_class'] else sys.stdout)
run_classifier(cls, Xt, Yt, Xt, Yt, labels, data,
report=report)
tcols.append((cls['name'], 'INTEGER'))
import pickle
with open('classification_results.pkl', 'w') as res:
pickle.dump(classifiers, res)
#classifiers = pickle.load(res)
msgr.message("Export the results to layer: <%s>" % str(rlayer))
export_results(vect, classifiers, cats, rlayer, vtraining, tcols,
overwrite(), pkl='res.pkl', append=flg['a'])
# res.close()
if flg['r']:
rules = ('\n'.join(['%d %s' % (k, v)
for k, v in get_colors(vtraining).items()])
if vtraining else None)
msgr.message("Export the layer with results to raster")
with Vector(vect, mode='r') as vct:
tab = vct.dblinks.by_name(rlayer).table()
rasters = [c for c in tab.columns]
rasters.remove(tab.key)
v2rst = Module('v.to.rast')
rclrs = Module('r.colors')
for rst in rasters:
v2rst(input=vect, layer=rlayer, type='area',
use='attr', attrcolumn=rst.encode(),
output=(opt['rst_names'] % rst).encode(),
memory=1000, overwrite=overwrite())
if rules:
rclrs(map=rst.encode(), rules='-', stdin_=rules)
def main(opts, flgs):
TMPVECT = []
DEBUG = True if flgs["d"] else False
atexit.register(cleanup, vect=TMPVECT, debug=DEBUG)
# check input maps
rhydro = ["kind_label", "discharge", "id_point", "id_plant"]
rother = ["kind_label", "discharge", "id_point", "id_plant"]
ovwr = overwrite()
try:
hydro = check_required_columns(
opts["hydro"], int(opts["hydro_layer"]), rhydro, "hydro"
)
if opts["other"]:
other = check_required_columns(
opts["other"], opts["other_layer"], rother, "other"
)
else:
other = None
# minflow = check_float_or_raster(opts['minflow'])
except ParameterError as exc:
exception2error(exc)
# start working
hydro.open("r")
el, mset = (
opts["elevation"].split("@")
if "@" in opts["elevation"]
else (opts["elevation"], "")
)
elev = RasterRow(name=el, mapset=mset)
elev.open("r")
# import ipdb; ipdb.set_trace()
plants, skipped = read_plants(
hydro,
elev=elev,
restitution=opts["hydro_kind_turbine"],
intake=opts["hydro_kind_intake"],
)
hydro.close()
rvname, rvmset = (
opts["river"].split("@") if "@" in opts["river"] else (opts["river"], "")
)
vplants = opts["output_plants"] if opts["output_plants"] else "tmpplants"
# FIXME: I try with tmpplants in my mapset and it doesn'work
if opts["output_plants"] == "":
TMPVECT.append(vplants)
with VectorTopo(rvname, rvmset, mode="r") as river:
write_plants(plants, vplants, river, elev, overwrite=ovwr)
if skipped:
for skip in skipped:
print("Plant: %r, Point: %r, kind: %r" % skip)
elev.close()
# compute a buffer around the plants
buff = vplants + "buff"
v.buffer(input=vplants, type="line", output=buff, distance=0.1, overwrite=ovwr)
TMPVECT.append(buff)
# return all the river segments that are not already with plants
v.overlay(
flags="t",
ainput=opts["river"],
atype="line",
binput=buff,
operator="not",
output=opts["output_streams"],
overwrite=ovwr,
)
#%end
#%flag
#% key: r
#% description: Remove all operational maps
#%end
import pdb
import numpy as np
import grass.script as grass
from grass.pygrass.messages import get_msgr
from grass.pygrass.raster import RasterRow
from grass.script.core import overwrite, parser, read_command, run_command
ow = overwrite()
def yield_pix_process(opts, flgs, yield_, yield_surface):
YPIX = ''
expr_surf = 'analysis_surface=' + opts['energy_map'] + '>0'
run_command('r.mapcalc', overwrite=ow, expression=expr_surf)
run_command("r.mapcalc",
overwrite=ow,
expression='yield_pix1 = (' + yield_ + '/' + yield_surface +
')*((ewres()*nsres())/10000)')
run_command("r.null", map="yield_pix1", null=0)
def main(opts, flgs):
ow = overwrite()
output = opts['output_basename']
forest = opts['forest']
boundaries = opts['boundaries']
yield_ = opts['forest_column_yield']
management = opts['forest_column_management']
treatment = opts['forest_column_treatment']
yield_surface = opts['forest_column_yield_surface']
roughness = opts['forest_column_roughness']
forest_roads = opts['forest_roads']
rivers = opts['rivers']
lakes = opts['lakes']
vector_forest = opts['forest']
tech_bioenergyHF = output + '_tech_bioenergyHF'
tech_bioenergyC = output + '_tech_bioenergyC'
tech_bioenergy = output + '_tech_bioenergy'
######## start import and convert ########
run_command("g.region", vect=boundaries)
run_command("v.to.rast",
input=forest,
output="yield",
use="attr",
attrcolumn=yield_,
overwrite=True)
run_command("v.to.rast",
input=forest,
output="yield_surface",
use="attr",
attrcolumn=yield_surface,
overwrite=True)
run_command("v.to.rast",
input=forest,
output="treatment",
use="attr",
attrcolumn=treatment,
overwrite=True)
run_command("v.to.rast",
input=forest,
output="management",
use="attr",
attrcolumn=management,
overwrite=True)
run_command("v.to.rast",
input=forest_roads,
output="forest_roads",
use="val",
overwrite=True)
run_command("r.null", map='yield', null=0)
run_command("r.null", map='yield_surface', null=0)
run_command("r.null", map='treatment', null=0)
run_command("r.null", map='management', null=0)
######## end import and convert ########
######## temp patch to link map and fields ######
management = "management"
treatment = "treatment"
yield_surface = "yield_surface"
yield_ = "yield"
forest_roads = "forest_roads"
######## end temp patch to link map and fields ######
if roughness == '':
run_command("r.mapcalc", overwrite=ow, expression='roughness=0')
roughness = 'roughness'
else:
run_command("v.to.rast",
input=forest,
output="roughness",
use="attr",
attrcolumn=roughness,
overwrite=True)
run_command("r.null", map='roughness', null=0)
CCEXTR = 'cable_crane_extraction = if(' + yield_ + '>0 && slope>' + opts[
'slp_min_cc'] + ' && slope<=' + opts[
'slp_max_cc'] + ' && extr_dist<' + opts['dist_max_cc'] + ', 1)'
FWEXTR = 'forwarder_extraction = if(' + yield_ + '>0 && slope<=' + opts[
'slp_max_fw'] + ' && ' + management + '==1 && (' + roughness + '==0 || ' + roughness + '==1 || ' + roughness + '==99999) && extr_dist<' + opts[
'dist_max_fw'] + ', 1)'
OEXTR = 'other_extraction = if(' + yield_ + '>0 && slope<=' + opts[
'slp_max_cop'] + ' && ' + management + '==2 && (' + roughness + '==0 || ' + roughness + '==1 || ' + roughness + '==99999) && extr_dist<' + opts[
'dist_max_cop'] + ', 1)'
EHF = tech_bioenergyHF + ' = technical_surface*(if(' + management + '==1 && ' + treatment + '==1 || ' + management + '==1 && ' + treatment + '==99999, yield_pix*' + opts[
'energy_tops_hf'] + ', if(' + management + '==1 && ' + treatment + '==2, yield_pix *' + opts[
'energy_tops_hf'] + ' + yield_pix * ' + opts[
'energy_cormometric_vol_hf'] + ')))'
ECC = tech_bioenergyC + ' = technical_surface*(if(' + management + ' == 2, yield_pix*' + opts[
'energy_tops_cop'] + '))'
ET = tech_bioenergy + ' = (' + tech_bioenergyC + ' + ' + tech_bioenergyHF + ')'
run_command("r.param.scale",
overwrite=ow,
input=opts['dtm'],
output="morphometric_features",
size=3,
method="feature")
run_command("r.slope.aspect",
overwrite=ow,
elevation=opts['dtm'],
slope="slope_deg")
run_command("r.mapcalc",
overwrite=ow,
expression='pix_cross = ((ewres()+nsres())/2)/ cos(slope_deg)')
run_command("r.mapcalc",
overwrite=ow,
expression='yield_pix1 = (' + yield_ + '/' + yield_surface +
')*((ewres()*nsres())/10000)')
run_command("r.null", map="yield_pix1", null=0)
run_command("r.null", map="morphometric_features", null=0)
exprmap = 'frict_surf_extr = pix_cross + if(yield_pix1<=0, 99999) + if(morphometric_features==6, 99999)'
if rivers != '':
run_command("v.to.rast",
input=rivers,
output="rivers",
use="val",
overwrite=True)
run_command("r.null", map="rivers", null=0)
rivers = "rivers"
exprmap += '+ if(' + rivers + '>=1, 99999)'
if lakes != '':
run_command("v.to.rast",
input=lakes,
output="lakes",
use="val",
overwrite=True)
run_command("r.null", map="lakes", null=0)
lakes = "lakes"
exprmap += '+ if(' + lakes + '>=1, 99999)'
#morphometric_features==6 -> peaks
#run_command("r.mapcalc", overwrite=ow,expression='frict_surf_extr = if(morphometric_features==6, 99999) + if(rivers>=1 || lakes>=1, 99999) + if(yield_pix1<=0, 99999) + pix_cross')
run_command("r.mapcalc", overwrite=ow, expression=exprmap)
run_command("r.cost",
overwrite=ow,
input="frict_surf_extr",
output="extr_dist",
stop_points=vector_forest,
start_rast=forest_roads,
max_cost=1500)
run_command("r.slope.aspect",
overwrite=ow,
elevation=opts['dtm'],
slope="slope",
format="percent")
run_command("r.mapcalc", overwrite=ow, expression=CCEXTR)
run_command("r.mapcalc", overwrite=ow, expression=FWEXTR)
run_command("r.mapcalc", overwrite=ow, expression=OEXTR)
run_command("r.null", map="cable_crane_extraction", null=0)
run_command("r.null", map="forwarder_extraction", null=0)
run_command("r.null", map="other_extraction", null=0)
run_command(
"r.mapcalc",
overwrite=ow,
expression=
'technical_surface = cable_crane_extraction + forwarder_extraction + other_extraction'
)
# run_command("r.statistics", overwrite=ow,
# base="compartment", cover="technical_surface", method="sum",
# output="techn_pix_comp")
# run_command("r.mapcalc", overwrite=ow,
# expression='yield_pix2 = yield/(technical_surface*@techn_pix_comp)')
# run_command("r.null", map="yield_pix2", null=0)
# run_command("r.mapcalc", overwrite=ow,
# expression=YPIX % (1 if flgs['u'] else 0, 0 if flgs['u'] else 1,))
run_command("r.mapcalc", overwrite=ow, expression="yield_pix=yield_pix1")
run_command("r.mapcalc", overwrite=ow, expression=EHF)
run_command("r.mapcalc", overwrite=ow, expression=ECC)
run_command("r.mapcalc", overwrite=ow, expression=ET)
with RasterRow(tech_bioenergy) as pT:
T = np.array(pT)
print("Resulted maps: " + output + "_tech_bioenergyHF, " + output +
"_tech_bioenergyC, " + output + "_tech_bioenergy")
print("Total bioenergy stimated (Mwh): %.2f" % np.nansum(T))
if flgs['r']:
remove_map(opts, flgs)
def main():
coords = options['coordinates']
input = options['input']
output = options['output']
fs = options['separator']
proj_in = options['proj_in']
proj_out = options['proj_out']
ll_in = flags['i']
ll_out = flags['o']
decimal = flags['d']
copy_input = flags['e']
include_header = flags['c']
#### check for cs2cs
if not grass.find_program('cs2cs'):
grass.fatal(_("cs2cs program not found, install PROJ.4 first: http://proj.maptools.org"))
#### check for overenthusiasm
if proj_in and ll_in:
grass.fatal(_("Choose only one input parameter method"))
if proj_out and ll_out:
grass.fatal(_("Choose only one output parameter method"))
if ll_in and ll_out:
grass.fatal(_("Choise only one auto-projection parameter method"))
if output and not grass.overwrite() and os.path.exists(output):
grass.fatal(_("Output file already exists"))
if not coords and not input:
grass.fatal(_("One of <coordinates> and <input> must be given"))
if coords and input:
grass.fatal(_("Options <coordinates> and <input> are mutually exclusive"))
#### parse field separator
# FIXME: input_x,y needs to split on multiple whitespace between them
if fs == ',':
ifs = ofs = ','
else:
try:
ifs, ofs = fs.split(',')
except ValueError:
ifs = ofs = fs
ifs = separator(ifs)
ofs = separator(ofs)
#### set up projection params
s = grass.read_command("g.proj", flags='j')
kv = parse_key_val(s)
if "XY location" in kv['+proj'] and (ll_in or ll_out):
grass.fatal(_("Unable to project to or from a XY location"))
in_proj = None
if ll_in:
in_proj = "+proj=longlat +datum=WGS84"
grass.verbose("Assuming LL WGS84 as input, current projection as output ")
if ll_out:
in_proj = grass.read_command('g.proj', flags = 'jf')
if proj_in:
in_proj = proj_in
if not in_proj:
grass.verbose("Assuming current location as input")
in_proj = grass.read_command('g.proj', flags = 'jf')
in_proj = in_proj.strip()
grass.verbose("Input parameters: '%s'" % in_proj)
out_proj = None
if ll_out:
out_proj = "+proj=longlat +datum=WGS84"
grass.verbose("Assuming current projection as input, LL WGS84 as output ")
if ll_in:
out_proj = grass.read_command('g.proj', flags = 'jf')
if proj_out:
out_proj = proj_out
if not out_proj:
grass.fatal(_("Missing output projection parameters "))
out_proj = out_proj.strip()
grass.verbose("Output parameters: '%s'" % out_proj)
#### set up input file
if coords:
x, y = coords.split(',')
tmpfile = grass.tempfile()
fd = open(tmpfile, "w")
fd.write("%s%s%s\n" % (x, ifs, y))
fd.close()
inf = file(tmpfile)
else:
if input == '-':
infile = None
inf = sys.stdin
else:
infile = input
if not os.path.exists(infile):
grass.fatal(_("Unable to read input data"))
inf = file(infile)
grass.debug("input file=[%s]" % infile)
#### set up output file
if not output:
outfile = None
outf = sys.stdout
else:
outfile = output
outf = open(outfile, 'w')
grass.debug("output file=[%s]" % outfile)
#### set up output style
if not decimal:
outfmt = ["-w5"]
else:
outfmt = ["-f", "%.8f"]
if not copy_input:
copyinp = []
else:
copyinp = ["-E"]
#### do the conversion
# Convert cs2cs DMS format to GRASS DMS format:
# cs2cs | sed -e 's/d/:/g' -e "s/'/:/g" -e 's/"//g'
cmd = ['cs2cs'] + copyinp + outfmt + in_proj.split() + ['+to'] + out_proj.split()
p = grass.Popen(cmd, stdin = grass.PIPE, stdout = grass.PIPE)
tr = TrThread(ifs, inf, p.stdin)
tr.start()
if not copy_input:
if include_header:
outf.write("x%sy%sz\n" % (ofs, ofs))
for line in p.stdout:
try:
xy, z = line.split(' ', 1)
x, y = xy.split('\t')
except ValueError:
grass.fatal(line)
outf.write('%s%s%s%s%s\n' % \
(x.strip(), ofs, y.strip(), ofs, z.strip()))
else:
if include_header:
outf.write("input_x%sinput_y%sx%sy%sz\n" % (ofs, ofs, ofs, ofs))
for line in p.stdout:
inXYZ, x, rest = line.split('\t')
inX, inY = inXYZ.split(' ')[:2]
y, z = rest.split(' ', 1)
outf.write('%s%s%s%s%s%s%s%s%s\n' % \
(inX.strip(), ofs, inY.strip(), ofs, x.strip(), \
ofs, y.strip(), ofs, z.strip()))
p.wait()
if p.returncode != 0:
grass.warning(_("Projection transform probably failed, please investigate"))
def main(opts, flgs):
ow = overwrite()
output = opts['output_basename']
forest = opts['forest']
boundaries = opts['boundaries']
yield_ = opts['forest_column_yield']
management = opts['forest_column_management']
treatment = opts['forest_column_treatment']
yield_surface = opts['forest_column_yield_surface']
l_bioenergyHF = output + '_l_bioenergyHF'
l_bioenergyC = output + '_l_bioenergyC'
l_bioenergy = output + '_l_bioenergy'
######## start import and convert ########
run_command("g.region", vect=boundaries)
run_command("v.to.rast",
input=forest,
output="yield",
use="attr",
attrcolumn=yield_,
overwrite=True)
run_command("v.to.rast",
input=forest,
output="yield_surface",
use="attr",
attrcolumn=yield_surface,
overwrite=True)
run_command("v.to.rast",
input=forest,
output="treatment",
use="attr",
attrcolumn=treatment,
overwrite=True)
run_command("v.to.rast",
input=forest,
output="management",
use="attr",
attrcolumn=management,
overwrite=True)
run_command("r.null", map='yield', null=0)
run_command("r.null", map='yield_surface', null=0)
run_command("r.null", map='treatment', null=0)
run_command("r.null", map='management', null=0)
######## end import and convert ########
######## temp patch to link map and fields ######
management = "management"
treatment = "treatment"
yield_surface = "yield_surface"
yield_ = "yield"
######## end temp patch to link map and fields ######
#import pdb; pdb.set_trace()
#treatment=1 final felling, treatment=2 thinning
ECOHF = l_bioenergyHF + ' = if(' + management + '==1 && ' + treatment + '==1 || ' + management + ' == 1 && ' + treatment + '==99999, yield_pix1*%f, if(' + management + '==1 && ' + treatment + '==2, yield_pix1*%f + yield_pix1*%f))'
#ECOHF = 'ecological_bioenergyHF = if(management==1 && treatment==1 || management == 1 && treatment==99999,yield_pix1*'+opts['energy_tops_hf']+', if(management==1 && treatment==2, yield_pix1*'+opts['energy_tops_hf']+' + yield_pix1*'+opts['energy_cormometric_vol_hf']+'))'
ECOCC = l_bioenergyC + ' = if(' + management + '==2, yield_pix1*' + opts[
'energy_tops_cop'] + ')'
ECOT = l_bioenergy + ' = (' + l_bioenergyHF + ' + ' + l_bioenergyC + ')'
run_command("r.mapcalc",
overwrite=ow,
expression='yield_pix1 = (' + yield_ + '/' + yield_surface +
')*((ewres()*nsres())/10000)')
run_command("r.mapcalc",
overwrite=ow,
expression=ECOHF % tuple(
map(float, (opts['energy_tops_hf'], opts['energy_tops_hf'],
opts['energy_cormometric_vol_hf']))))
run_command("r.mapcalc", overwrite=ow, expression=ECOCC)
run_command("r.mapcalc", overwrite=ow, expression=ECOT)
with RasterRow(l_bioenergy) as pT:
T = np.array(pT)
print("Resulted maps: " + output + "_l_bioenergyHF, " + output +
"_l_bioenergyC, " + output + "_l_bioenergy")
print("Total bioenergy stimated (Mwh): %.2f" % np.nansum(T))
def main():
options, flags = gcore.parser()
elevation = options["elevation"]
strds = options["output"]
basename = strds
start_water_level = float(options["start_water_level"])
end_water_level = float(options["end_water_level"])
water_level_step = float(options["water_level_step"])
# if options['coordinates']:
# options['coordinates'].split(',')
# passing coordinates parameter as is
coordinates = options["coordinates"]
seed_raster = options["seed_raster"]
if seed_raster and coordinates:
gcore.fatal(
_("Both seed raster and coordinates cannot be specified"
" together, please specify only one of them."))
time_unit = options["time_unit"]
time_step = options[
"time_step"] # temporal fucntions accepts only string now
if int(time_step) <= 0:
gcore.fatal(
_("Time step must be greater than zero."
" Please specify number > 0."))
mapset = gcore.gisenv()["MAPSET"]
title = _("r.lake series")
desctiption = _("r.lake series")
water_levels = [
step for step in frange(start_water_level, end_water_level,
water_level_step)
]
outputs = [
"%s%s%s" % (basename, "_", water_level) for water_level in water_levels
]
if not gcore.overwrite():
check_maps_exist(outputs, mapset)
kwargs = {}
if seed_raster:
kwargs["seed"] = seed_raster
elif coordinates:
kwargs["coordinates"] = coordinates
if flags["n"]:
pass_flags = "n"
else:
pass_flags = None
for i, water_level in enumerate(water_levels):
try:
gcore.run_command(
"r.lake",
flags=pass_flags,
elevation=elevation,
lake=outputs[i],
water_level=water_level,
overwrite=gcore.overwrite(
), # TODO: really works? Its seems that hardcoding here False does not prevent overwriting.
**kwargs)
except CalledModuleError:
# remove maps created so far, try to remove also i-th map
remove_raster_maps(outputs[:i], quiet=True)
gcore.fatal(
_("r.lake command failed. Check above error messages."
" Try different water levels or seed points."))
gcore.info(_("Registering created maps into temporal dataset..."))
# Make sure the temporal database exists
tgis.init()
tgis.open_new_stds(
strds,
type="strds",
temporaltype="relative",
title=title,
descr=desctiption,
semantic="sum",
dbif=None,
overwrite=gcore.overwrite(),
)
# TODO: we must start from 1 because there is a bug in register_maps_in_space_time_dataset
tgis.register_maps_in_space_time_dataset(
type="raster",
name=basename,
maps=",".join(outputs),
start=str(1),
end=None,
unit=time_unit,
increment=time_step,
interval=False,
dbif=None,
)
