def set_region_from_raster(self, raster):
"""Sets computational region for rendering.
This functions sets computational region based on
a raster map in the target environment.
If user specified the name of saved region during object's initialization,
the provided region is used. If it's not specified
and use_region=True, current region is used.
Also enlarges bounding box based on the raster.
"""
if self._saved_region:
self._src_env["GRASS_REGION"] = gs.region_env(
region=self._saved_region, env=self._src_env)
elif self._use_region:
# use current
self._set_bbox(self._src_env)
return
else:
self._src_env["GRASS_REGION"] = gs.region_env(raster=raster,
env=self._src_env)
region = get_region(env=self._src_env)
from_proj = get_location_proj_string(self._src_env)
to_proj = get_location_proj_string(env=self._tgt_env)
new_region = reproject_region(region, from_proj, to_proj)
gs.run_command(
"g.region",
n=new_region["north"],
s=new_region["south"],
e=new_region["east"],
w=new_region["west"],
env=self._tgt_env,
)
self._set_bbox(self._src_env)
def set_region_from_timeseries(self, timeseries):
"""Sets computational region for rendering.
This function sets the computation region from the extent of
a space-time dataset by using its bounding box and resolution.
If user specified the name of saved region during object's initialization,
the provided region is used. If it's not specified
and use_region=True, current region is used.
"""
if self._saved_region:
self._env["GRASS_REGION"] = gs.region_env(
region=self._saved_region, env=self._env)
return
if self._use_region:
# use current
return
# Get extent, resolution from space time dataset
info = gs.parse_command("t.info",
input=timeseries,
flags="g",
env=self._env)
# Set grass region from extent
self._env["GRASS_REGION"] = gs.region_env(
n=info["north"],
s=info["south"],
e=info["east"],
w=info["west"],
nsres=info["nsres_min"],
ewres=info["ewres_min"],
)
def set_region_from_command(self, env, **kwargs):
"""Sets computational region for rendering.
This functions identifies a raster map from m.nviz.image command
and tries to set computational region based on that.
If user specified the name of saved region during object's initialization,
the provided region is used. If it's not specified
and use_region=True, current region is used.
"""
if self._saved_region:
env["GRASS_REGION"] = gs.region_env(region=self._saved_region,
env=env)
self._region_set = True
return
if self._use_region:
# use current
return
if self._region_set:
return
if "elevation_map" in kwargs:
elev = kwargs["elevation_map"].split(",")[0]
try:
env["GRASS_REGION"] = gs.region_env(raster=elev, env=env)
self._region_set = True
except CalledModuleError:
return
def ImportMapIntoGRASS(self, raster):
"""!Import raster into GRASS.
"""
# importing temp_map into GRASS
try:
# -o flag needed to overcome different ellipsoid representations
grass.run_command('r.in.gdal', flags='o',
quiet=True, overwrite=True,
input=raster, output=self.opt_output)
except CalledModuleError:
grass.fatal(_('%s failed') % 'r.in.gdal')
# information for destructor to cleanup temp_layers, created
# with r.in.gdal
self.cleanup_layers = True
# setting region for full extend of imported raster
if grass.find_file(self.opt_output + '.red', element='cell', mapset='.')['file']:
region_map = self.opt_output + '.red'
else:
region_map = self.opt_output
os.environ['GRASS_REGION'] = grass.region_env(rast=region_map)
# mask created from alpha layer, which describes real extend
# of warped layer (may not be a rectangle), also mask contains
# transparent parts of raster
if grass.find_file(self.opt_output + '.alpha', element='cell', mapset='.')['name']:
# saving current mask (if exists) into temp raster
if grass.find_file('MASK', element='cell', mapset='.')['name']:
try:
mask_copy = self.opt_output + self.original_mask_suffix
grass.run_command('g.copy', quiet=True,
raster='MASK,' + mask_copy)
except CalledModuleError:
grass.fatal(_('%s failed') % 'g.copy')
# info for destructor
self.cleanup_mask = True
try:
grass.run_command('r.mask',
quiet=True, overwrite=True,
maskcats="0",
flags='i',
raster=self.opt_output + '.alpha')
except CalledModuleError:
grass.fatal(_('%s failed') % 'r.mask')
# TODO one band + alpha band?
if grass.find_file(self.opt_output + '.red', element='cell', mapset='.')['file']:
try:
grass.run_command('r.composite',
quiet=True, overwrite=True,
red=self.opt_output + '.red',
green=self.opt_output + '.green',
blue=self.opt_output + '.blue',
output=self.opt_output)
except CalledModuleError:
grass.fatal(_('%s failed') % 'r.composite')
grass.message(_('<%s> created.') % self.opt_output)
def OnReproject(self, event):
cmd = []
if self.etype == 'raster':
cmd.append('r.proj')
cmd.append('dbase=' + self.iGisdbase)
cmd.append('location=' + self.iLocation)
cmd.append('mapset=' + self.iMapset)
cmd.append('input=' + self.iLayer)
cmd.append('output=' + self.oLayer)
cmd.append('method=' + self.resampling.GetStringSelection())
self.oEnv['GRASS_REGION'] = region_env(n=self.params['n'], s=self.params['s'],
e=self.params['e'], w=self.params['w'],
flags='a', res=float(self.resolution.GetValue()),
env=self.oEnv)
else:
cmd.append('v.proj')
cmd.append('dbase=' + self.iGisdbase)
cmd.append('location=' + self.iLocation)
cmd.append('mapset=' + self.iMapset)
cmd.append('input=' + self.iLayer)
cmd.append('output=' + self.oLayer)
cmd.append('smax=' + self.vsplit.GetValue())
self._giface.RunCmd(cmd, env=self.oEnv, compReg=False, addLayer=False,
onDone=self._onDone, userData=None,
notification=Notification.MAKE_VISIBLE)
event.Skip()
def indicatrix(raster, size):
env = os.environ.copy()
env['GRASS_OVERWRITE'] = '1'
env['GRASS_VERBOSE'] = '0'
env['GRASS_REGION'] = gscript.region_env(raster=raster)
info = gscript.raster_info(raster)
number = [3, 5]
ew = info['east'] - info['west']
ns = info['north'] - info['south']
ew_step = ew / float(number[0] + 1)
ns_step = ns / float(number[1] + 1)
name = raster + '_indicatrix'
circle_tmp = 'tmp_circle'
circle_tmp2 = 'tmp_circle2'
gscript.mapcalc('{} = null()'.format(circle_tmp2), overwrite=True)
for i in range(number[0]):
for j in range(number[1] - 1):
gscript.run_command('r.circle', output=circle_tmp, min=size, max=size + 1, flags='b',
coordinates=[info['west'] + (i + 1) * ew_step, info['south'] + (j + 1) * ns_step],
env=env)
gscript.run_command('r.patch', input=[circle_tmp, circle_tmp2], output=name, env=env)
gscript.run_command('g.copy', raster=[name, circle_tmp2], env=env)
gscript.run_command('r.to.vect', input=name, output=name, type='line', flags='vt', env=env)
gscript.run_command('g.remove', type='raster', flags='f', name=[circle_tmp, circle_tmp2], env=env)
return name
def set_bbox_vector(self, vector):
"""Enlarge bounding box based on vector"""
if self._saved_region or self._use_region:
return
env = self._src_env.copy()
env["GRASS_REGION"] = gs.region_env(vector=vector, env=env)
self._set_bbox(env)
def ImportMapIntoGRASS(self, raster):
"""!Import raster into GRASS.
"""
grass.message(_("Importing raster map into GRASS..."))
if not raster:
grass.warning(_("Nothing to import.\nNo data has been downloaded from wms server."))
return
# importing temp_map into GRASS
if grass.run_command('r.in.gdal',
quiet = True,
input = raster,
output = self.opt_output) != 0:
grass.fatal(_('%s failed') % 'r.in.gdal')
# information for destructor to cleanup temp_layers, created
# with r.in.gdal
self.cleanup_layers = True
# setting region for full extend of imported raster
if grass.find_file(self.opt_output + '.red', element = 'cell', mapset = '.')['file']:
region_map = self.opt_output + '.red'
else:
region_map = self.opt_output
os.environ['GRASS_REGION'] = grass.region_env(rast = region_map)
# mask created from alpha layer, which describes real extend
# of warped layer (may not be a rectangle), also mask contains
# transparent parts of raster
if grass.find_file( self.opt_output + '.alpha', element = 'cell', mapset = '.' )['name']:
# saving current mask (if exists) into temp raster
if grass.find_file('MASK', element = 'cell', mapset = '.' )['name']:
if grass.run_command('g.copy',
quiet = True,
rast = 'MASK,' + self.opt_output + self.original_mask_suffix) != 0:
grass.fatal(_('%s failed') % 'g.copy')
# info for destructor
self.cleanup_mask = True
if grass.run_command('r.mask',
quiet = True,
overwrite = True,
maskcats = "0",
flags = 'i',
input = self.opt_output + '.alpha') != 0:
grass.fatal(_('%s failed') % 'r.mask')
#TODO one band + alpha band?
if grass.find_file(self.opt_output + '.red', element = 'cell', mapset = '.')['file']:
if grass.run_command('r.composite',
quiet = True,
red = self.opt_output + '.red',
green = self.opt_output + '.green',
blue = self.opt_output + '.blue',
output = self.opt_output ) != 0:
grass.fatal(_('%s failed') % 'r.composite')
grass.message(_('<%s> created.') % self.opt_output)
def set_region_from_raster(self, raster):
"""Sets computational region for rendering.
This functions sets computational region based on
a raster map in the target environment.
If user specified the name of saved region during object's initialization,
the provided region is used. If it's not specified
and use_region=True, current region is used.
Also enlarges bounding box based on the raster.
"""
if self._use_region or self._saved_region:
# target region and bbox already set
return
# set target location region extent
self._src_env["GRASS_REGION"] = gs.region_env(raster=raster,
env=self._src_env)
set_target_region(src_env=self._src_env, tgt_env=self._tgt_env)
# set resolution based on r.proj estimate
env_info = gs.gisenv(env=self._src_env)
name, mapset = raster.split("@")
self._resolution = estimate_resolution(
raster=name,
mapset=mapset,
location=env_info["LOCATION_NAME"],
dbase=env_info["GISDBASE"],
env=self._tgt_env,
)
self._set_bbox(self._src_env)
def __init__(self, use_region, saved_region, src_env, tgt_env):
"""Manages region during rendering for interactive map.
:param use_region: if True, use either current or provided saved region,
else derive region from rendered layers
:param saved_region: if name of saved_region is provided,
this region is then used for rendering
:param src_env: source environment (original projection)
:param tgt_env: target environment (pseudomercator)
"""
self._use_region = use_region
self._saved_region = saved_region
self._src_env = src_env
self._tgt_env = tgt_env
self._resolution = None
# [SW, NE]: inverted to easily expand based on data, see _set_bbox
self._bbox = [[90, 180], [-90, -180]]
if self._use_region:
# tgt region already set, set resolution
self._resolution = self._get_psmerc_region_resolution()
self._set_bbox(self._src_env)
if self._saved_region:
self._src_env["GRASS_REGION"] = gs.region_env(
region=self._saved_region, env=self._src_env)
set_target_region(src_env=self._src_env, tgt_env=self._tgt_env)
self._resolution = self._get_psmerc_region_resolution()
self._set_bbox(self._src_env)
def function(elemns):
elem = str(elemns)
outf='res_'+str(elem)+'.txt'
os.environ['GRASS_REGION'] = grass.region_env(res=elem)
#varx = grass.read_command ('g.region',flags='g'). splitlines ()
grass.run_command('r.univar',map='elevation',flags='g',out=outf,overwrite=True)
os.environ.pop('GRASS_REGION')
def ImportMapIntoGRASS(self, raster):
"""!Import raster into GRASS.
"""
# importing temp_map into GRASS
try:
grass.run_command('r.in.gdal',
quiet=True, overwrite=True,
input=raster, output=self.opt_output)
except CalledModuleError:
grass.fatal(_('%s failed') % 'r.in.gdal')
# information for destructor to cleanup temp_layers, created
# with r.in.gdal
self.cleanup_layers = True
# setting region for full extend of imported raster
if grass.find_file(self.opt_output + '.red', element = 'cell', mapset = '.')['file']:
region_map = self.opt_output + '.red'
else:
region_map = self.opt_output
os.environ['GRASS_REGION'] = grass.region_env(rast = region_map)
# mask created from alpha layer, which describes real extend
# of warped layer (may not be a rectangle), also mask contains
# transparent parts of raster
if grass.find_file( self.opt_output + '.alpha', element = 'cell', mapset = '.' )['name']:
# saving current mask (if exists) into temp raster
if grass.find_file('MASK', element = 'cell', mapset = '.' )['name']:
try:
mask_copy = self.opt_output + self.original_mask_suffix
grass.run_command('g.copy', quiet=True,
raster='MASK,' + mask_copy)
except CalledModuleError:
grass.fatal(_('%s failed') % 'g.copy')
# info for destructor
self.cleanup_mask = True
try:
grass.run_command('r.mask',
quiet=True, overwrite=True,
maskcats="0",
flags='i',
raster=self.opt_output + '.alpha')
except CalledModuleError:
grass.fatal(_('%s failed') % 'r.mask')
#TODO one band + alpha band?
if grass.find_file(self.opt_output + '.red', element = 'cell', mapset = '.')['file']:
try:
grass.run_command('r.composite',
quiet=True, overwrite=True,
red=self.opt_output + '.red',
green=self.opt_output + '.green',
blue=self.opt_output + '.blue',
output=self.opt_output)
except CalledModuleError:
grass.fatal(_('%s failed') % 'r.composite')
grass.message(_('<%s> created.') % self.opt_output)
def ImportMapIntoGRASS(self, raster):
"""!Import raster into GRASS.
"""
# importing temp_map into GRASS
if grass.run_command("r.in.gdal", quiet=True, overwrite=True, input=raster, output=self.opt_output) != 0:
grass.fatal(_("%s failed") % "r.in.gdal")
# information for destructor to cleanup temp_layers, created
# with r.in.gdal
self.cleanup_layers = True
# setting region for full extend of imported raster
if grass.find_file(self.opt_output + ".red", element="cell", mapset=".")["file"]:
region_map = self.opt_output + ".red"
else:
region_map = self.opt_output
os.environ["GRASS_REGION"] = grass.region_env(rast=region_map)
# mask created from alpha layer, which describes real extend
# of warped layer (may not be a rectangle), also mask contains
# transparent parts of raster
if grass.find_file(self.opt_output + ".alpha", element="cell", mapset=".")["name"]:
# saving current mask (if exists) into temp raster
if grass.find_file("MASK", element="cell", mapset=".")["name"]:
if (
grass.run_command("g.copy", quiet=True, rast="MASK," + self.opt_output + self.original_mask_suffix)
!= 0
):
grass.fatal(_("%s failed") % "g.copy")
# info for destructor
self.cleanup_mask = True
if (
grass.run_command(
"r.mask", quiet=True, overwrite=True, maskcats="0", flags="i", raster=self.opt_output + ".alpha"
)
!= 0
):
grass.fatal(_("%s failed") % "r.mask")
# TODO one band + alpha band?
if grass.find_file(self.opt_output + ".red", element="cell", mapset=".")["file"]:
if (
grass.run_command(
"r.composite",
quiet=True,
overwrite=True,
red=self.opt_output + ".red",
green=self.opt_output + ".green",
blue=self.opt_output + ".blue",
output=self.opt_output,
)
!= 0
):
grass.fatal(_("%s failed") % "r.composite")
grass.message(_("<%s> created.") % self.opt_output)
def set_region_from_command(self, module, **kwargs):
"""Sets computational region for rendering.
This functions identifies a raster/vector map from command
and tries to set computational region based on that.
It takes the extent from the first layer (raster or vector)
and resolution and alignment from first raster layer.
If user specified the name of saved region during object's initialization,
the provided region is used. If it's not specified
and use_region=True, current region is used.
"""
if self._saved_region:
self._env["GRASS_REGION"] = gs.region_env(
region=self._saved_region, env=self._env)
return
if self._use_region:
# use current
return
if self._resolution_set and self._extent_set:
return
name = get_map_name_from_d_command(module, **kwargs)
if not name:
return
if len(name.split()) > 1:
name = name.split()[0]
try:
if module.startswith("d.vect"):
if not self._resolution_set and not self._extent_set:
self._env["GRASS_REGION"] = gs.region_env(vector=name,
env=self._env)
self._extent_set = True
else:
if not self._resolution_set and not self._extent_set:
self._env["GRASS_REGION"] = gs.region_env(raster=name,
env=self._env)
self._extent_set = True
self._resolution_set = True
elif not self._resolution_set:
self._env["GRASS_REGION"] = gs.region_env(align=name,
env=self._env)
self._resolution_set = True
except CalledModuleError:
return
def function(elemns):
elem = str(elemns)
outf = 'res_' + str(elem) + '.txt'
os.environ['GRASS_REGION'] = grass.region_env(res=elem)
#varx = grass.read_command ('g.region',flags='g'). splitlines ()
grass.run_command('r.univar',
map='elevation',
flags='g',
out=outf,
overwrite=True)
os.environ.pop('GRASS_REGION')
def futures_process(params):
repeat, seed, cat, options = params
try:
if cat:
gscript.message(_("Running simulation {s}/{r} for subregion {sub}".format(s=seed, r=repeat, sub=cat)))
env = os.environ.copy()
env['GRASS_REGION'] = gscript.region_env(raster=PREFIX + cat, zoom=PREFIX + cat)
gscript.run_command('r.futures.pga', env=env, **options)
else:
gscript.message(_("Running simulation {s}/{r}".format(s=seed, r=repeat)))
gscript.run_command('r.futures.pga', **options)
except (KeyboardInterrupt, CalledModuleError):
return
def compute(params):
env = os.environ.copy()
region = params.pop("region")
env["GRASS_REGION"] = gs.region_env(**region)
results = gs.read_command("r.futures.validation",
format="json",
env=env,
quiet=True,
**params)
results = json.loads(results)
reg = gs.region(env=env)
results["n"] = (reg["n"] + reg["s"]) / 2
results["e"] = (reg["e"] + reg["w"]) / 2
return results
def get_environment(**kwargs):
"""!Returns environment for running modules.
All modules for which region is important should
pass this environment into run_command or similar.
@param tmp_regions a list of temporary regions
@param kwargs arguments for g.region
@return environment as a dictionary
"""
env = os.environ.copy()
env['GRASS_OVERWRITE'] = '1'
env['GRASS_VERBOSE'] = '0'
env['GRASS_MESSAGE_FORMAT'] = 'standard'
env['GRASS_REGION'] = gscript.region_env(**kwargs)
return env
def get_environment(**kwargs):
"""!Returns environment for running modules.
All modules for which region is important should
pass this environment into run_command or similar.
@param tmp_regions a list of temporary regions
@param kwargs arguments for g.region
@return environment as a dictionary
"""
env = os.environ.copy()
env['GRASS_OVERWRITE'] = '1'
env['GRASS_VERBOSE'] = '0'
env['GRASS_MESSAGE_FORMAT'] = 'standard'
env['GRASS_REGION'] = gscript.region_env(**kwargs)
return env
def getEnvironment(gisdbase, location, mapset):
"""Creates an environment to be passed in run_command.
Returns a tuple with a temporary file path and an environment.
The user should delete this temporary file."""
tmp_gisrc_file = gscript.tempfile()
with open(tmp_gisrc_file, 'w') as f:
f.write('MAPSET: {mapset}\n'.format(mapset=mapset))
f.write('GISDBASE: {g}\n'.format(g=gisdbase))
f.write('LOCATION_NAME: {l}\n'.format(l=location))
f.write('GUI: text\n')
env = os.environ.copy()
env['GISRC'] = tmp_gisrc_file
env['GRASS_REGION'] = gscript.region_env(raster=region, res=res)
env['GRASS_OVERWRITE'] = '1'
env['GRASS_VERBOSE'] = '0'
env['GRASS_MESSAGE_FORMAT'] = 'standard'
return tmp_gisrc_file, env
def getEnvironment(gisdbase, location, mapset):
"""Creates environment to be passed in run_command for example.
Returns tuple with temporary file path and the environment. The user
of this function is responsile for deleting the file."""
tmp_gisrc_file = gscript.tempfile()
with open(tmp_gisrc_file, 'w') as f:
f.write('MAPSET: {mapset}\n'.format(mapset=mapset))
f.write('GISDBASE: {g}\n'.format(g=gisdbase))
f.write('LOCATION_NAME: {l}\n'.format(l=location))
f.write('GUI: text\n')
env = os.environ.copy()
env['GISRC'] = tmp_gisrc_file
env['GRASS_REGION'] = gscript.region_env(raster='elevation_2004@PERMANENT')
env['GRASS_OVERWRITE'] = '1'
env['GRASS_VERBOSE'] = '0'
env['GRASS_MESSAGE_FORMAT'] = 'standard'
return tmp_gisrc_file, env
def run_process(seg_cat, segments, nodes_by_id, railroads):
cells = {}
env = os.environ.copy()
node_id = segments[seg_cat][0]
print(seg_cat)
gs.run_command(
"v.to.rast",
input=railroads + "_simplified",
quiet=True,
type="line",
cats=seg_cat,
output=railroads + "_segment_" + str(seg_cat),
use="val",
)
gs.run_command(
"r.patch",
input=[railroads + "_segment_" + str(seg_cat), railroads + "_nodes"],
output=railroads + "_" + str(seg_cat),
quiet=True,
)
env["GRASS_REGION"] = gs.region_env(zoom=railroads + "_" + str(seg_cat))
gs.run_command(
"r.cost",
flags="n",
input=railroads + "_" + str(seg_cat),
output=railroads + "_cumcost_" + str(seg_cat),
start_coordinates=nodes_by_id[node_id],
quiet=True,
env=env,
)
stats = gs.read_command(
"r.stats",
output="-",
flags="xn",
quiet=True,
input=railroads + "_cumcost_" + str(seg_cat),
).strip()
cells[seg_cat] = []
for line in stats.splitlines():
row, col, cost = line.strip().split()
row, col, cost = int(row), int(col), float(cost)
cells[seg_cat].append((cost, row, col))
cells[seg_cat].sort()
return cells
def _create_grass_region_env(self, bbox):
r = self.an_data.GetRegion()
new_r = {}
if bbox["maxy"] <= r["s"]:
return 0
elif bbox["maxy"] >= r["n"]:
new_r["n"] = bbox["maxy"]
else:
new_r["n"] = (ceil(
(bbox["maxy"] - r["s"]) / r["nsres"]) * r["nsres"] + r["s"])
if bbox["miny"] >= r["n"]:
return 0
elif bbox["miny"] <= r["s"]:
new_r["s"] = bbox["miny"]
else:
new_r["s"] = (floor(
(bbox["miny"] - r["s"]) / r["nsres"]) * r["nsres"] + r["s"])
if bbox["maxx"] <= r["w"]:
return 0
elif bbox["maxx"] >= r["e"]:
new_r["e"] = bbox["maxx"]
else:
new_r["e"] = (ceil(
(bbox["maxx"] - r["w"]) / r["ewres"]) * r["ewres"] + r["w"])
if bbox["minx"] >= r["e"]:
return 0
elif bbox["minx"] <= r["w"]:
new_r["w"] = bbox["minx"]
else:
new_r["w"] = (floor(
(bbox["minx"] - r["w"]) / r["ewres"]) * r["ewres"] + r["w"])
# TODO check regions resolution
new_r["nsres"] = r["nsres"]
new_r["ewres"] = r["ewres"]
return {"GRASS_REGION": grass.region_env(**new_r)}
def _create_grass_region_env(self, bbox):
r = self.an_data.GetRegion()
new_r = {}
if bbox["maxy"] <= r["s"]:
return 0
elif bbox["maxy"] >= r["n"]:
new_r["n"] = bbox["maxy"]
else:
new_r["n"] = ceil(
(bbox["maxy"] - r["s"]) / r["nsres"]) * r["nsres"] + r["s"]
if bbox["miny"] >= r["n"]:
return 0
elif bbox["miny"] <= r["s"]:
new_r["s"] = bbox["miny"]
else:
new_r["s"] = floor(
(bbox["miny"] - r["s"]) / r["nsres"]) * r["nsres"] + r["s"]
if bbox["maxx"] <= r["w"]:
return 0
elif bbox["maxx"] >= r["e"]:
new_r["e"] = bbox["maxx"]
else:
new_r["e"] = ceil(
(bbox["maxx"] - r["w"]) / r["ewres"]) * r["ewres"] + r["w"]
if bbox["minx"] >= r["e"]:
return 0
elif bbox["minx"] <= r["w"]:
new_r["w"] = bbox["minx"]
else:
new_r["w"] = floor(
(bbox["minx"] - r["w"]) / r["ewres"]) * r["ewres"] + r["w"]
# TODO check regions resolution
new_r["nsres"] = r["nsres"]
new_r["ewres"] = r["ewres"]
return {"GRASS_REGION": grass.region_env(**new_r)}
def OnReproject(self, event):
cmd = []
if self.etype == "raster":
cmd.append("r.proj")
cmd.append("dbase=" + self.iGisdbase)
cmd.append("location=" + self.iLocation)
cmd.append("mapset=" + self.iMapset)
cmd.append("input=" + self.iLayer)
cmd.append("output=" + self.oLayer)
cmd.append("method=" + self.resampling.GetStringSelection())
self.oEnv["GRASS_REGION"] = region_env(
n=self.params["n"],
s=self.params["s"],
e=self.params["e"],
w=self.params["w"],
flags="a",
res=float(self.resolution.GetValue()),
env=self.oEnv,
)
else:
cmd.append("v.proj")
cmd.append("dbase=" + self.iGisdbase)
cmd.append("location=" + self.iLocation)
cmd.append("mapset=" + self.iMapset)
cmd.append("input=" + self.iLayer)
cmd.append("output=" + self.oLayer)
cmd.append("smax=" + self.vsplit.GetValue())
self._giface.RunCmd(
cmd,
env=self.oEnv,
compReg=False,
addLayer=False,
onDone=self._onDone,
userData=None,
notification=Notification.MAKE_VISIBLE,
)
event.Skip()
def main():
# Following declarations MAY will used in future for sure.
global GISDBASE, LAYERCOUNT, LASTFILE
# Check if ImageMagick is available since it is essential
if os.name == 'nt':
if grass.find_program('magick', '-version'):
grass.verbose(_('printws: ImageMagick is available: OK!'))
else:
grass.fatal(
'ImageMagick is not accessible. See documentation of m.printws module for details.'
)
else:
if grass.find_program('convert', '-version'):
grass.verbose(_('printws: ImageMagick is available: OK!'))
else:
grass.fatal(
'ImageMagick is not accessible. See documentation of m.printws module for details.'
)
textmacros = {}
# %nam% macros are kept for backward compatibility
textmacros['%TIME24%'] = time.strftime("%H:%M:%S")
textmacros['%DATEYMD%'] = time.strftime("%Y.%m.%d")
textmacros['%DATEMDY%'] = time.strftime("%m/%d/%Y")
if not hasPwd:
textmacros['%USERNAME%'] = '(user unknown)'
else:
textmacros['%USERNAME%'] = pwd.getpwuid(os.getuid())[0]
# using $ for macros in the future. New items should be created
# exclusively as $macros later on
textmacros['\$TIME24'] = textmacros['%TIME24%']
textmacros['\$DATEYMD'] = textmacros['%DATEYMD%']
textmacros['\$DATEMDY'] = textmacros['%DATEMDY%']
textmacros['\$USERNAME'] = textmacros['%USERNAME%']
textmacros[
'\$SPC'] = u'\u00A0' #?? d.text won't display this at string end hmmm
# saves region for restoring at end
# doing with official method:
grass.use_temp_region()
# getting/setting screen/print dpi ratio
if len(options['dpi']) > 0:
dpioption = float(options['dpi'])
else:
dpioption = 150.0
if len(options['screendpi']) > 0:
screendpioption = float(options['screendpi'])
else:
screendpioption = 100.0
global UPSIZE
UPSIZE = float(dpioption) / float(screendpioption)
if len(options['input']) > 0:
displays = readworkspace(options['input'])
else:
quit()
textmacros['%GXW%'] = options['input']
textmacros['\$GXW'] = textmacros['%GXW%']
displaycounter = 0
# there could be multiple displays in a workspace so we loop them
# each display is a whole and independent file assembly
for key in displays:
textmacros['%DISPLAY%'] = key
textmacros['\$DISPLAY'] = key
grass.verbose(_('printws: rendering display: ' + key))
displaycounter = displaycounter + 1
layers = copy.deepcopy(displays[key])
# extracting extent information from layers dic and erase the item
# extents[0-5] w s e n minz maxz ; extents [6-9] window x y w h
extents = layers[0]
grass.verbose("m.printws: EXTENTS from workspace:" +
str(extents)) # was debug message
del layers[0]
regionmode = ''
if len(options['region']) > 0:
grass.run_command("g.region", region=options['region'])
regionmode = 'region'
else:
grass.run_command("g.region",
"",
w=extents[0],
s=extents[1],
e=extents[2],
n=extents[3])
regionmode = 'window'
# setting GRASS rendering environment
# dummy file name is defined since the following lines
# when switching on the cairo driver would create
# an empty map.png in the current directory
os.environ['GRASS_RENDER_FILE'] = os.path.join(
TMPDIR,
str(os.getpid()) + '_DIS_' + str(00) + '_GEN_' + str(00) + '.png')
os.environ['GRASS_RENDER_IMMEDIATE'] = 'cairo'
os.environ['GRASS_RENDER_FILE_READ'] = 'TRUE'
os.environ['GRASS_RENDER_TRANSPARENT'] = 'TRUE'
os.environ['GRASS_RENDER_FILE_COMPRESSION'] = '0'
os.environ['GRASS_RENDER_FILE_MAPPED'] = 'TRUE'
# reading further options and setting defaults
if len(options['page']) > 0:
pageoption = options['page']
else:
pageoption = 'A4landscape'
# parsing titles, etc.
if len(options['font']) > 0:
isAsterisk = options['font'].find('*')
if isAsterisk > 0:
titlefont = getfontbypattern(options['font'].replace('*', ''))
else:
titlefont = options['font']
else:
titlefont = getfontbypattern('Open') # try to find something UTF-8
grass.verbose(_("printws: titlefont: " + titlefont))
if len(options['titlecolor']) > 0:
titlecolor = options['titlecolor']
else:
titlecolor = black
if len(options['maintitlesize']) > 0:
maintitlesize = converttommfrom(float(options['maintitlesize']),
options['layunits'])
else:
maintitlesize = 10.0
if len(options['subtitlesize']) > 0:
subtitlesize = converttommfrom(float(options['subtitlesize']),
options['layunits'])
else:
subtitlesize = 7.0
if len(options['pssize']) > 0:
pssize = converttommfrom(float(options['pssize']),
options['layunits'])
else:
pssize = 5.0
# Please fasten your seatbelts :) Calculations start here.
# -------------------------------------------------------------------
pagesizes = getpagesizes(pageoption)
pagesizesindots = dictodots(pagesizes, dpioption)
# Leave space for titles up and ps down - still in mm !!
upperspace = 0
subtitletop = 0
titletop = 0
if len(options['maintitle']) > 0:
titletop = 0.4 * maintitlesize
upperspace = upperspace + titletop + maintitlesize
if len(options['subtitle']) > 0:
subtitletop = upperspace + 0.4 * subtitlesize
upperspace = subtitletop + subtitlesize + 1
lowerspace = 0
if (len(options['psundercentral']) > 0) or (len(
options['psunderright']) > 0) or (len(options['psunderleft']) >
0):
lowerspace = lowerspace + pssize + 2
os.environ['GRASS_RENDER_WIDTH'] = str(pagesizesindots['w'])
os.environ['GRASS_RENDER_HEIGHT'] = str(pagesizesindots['h'])
pagemargins = getpagemargins(options['pagemargin'],
options['layunits'])
pagemarginsindots = dictodots(pagemargins, dpioption)
# Getting max drawing area in dots
mxfd = getmaxframeindots(pagemarginsindots, pagesizesindots)
maxframe = str(mxfd['t']) + ',' + str(mxfd['b']) + \
',' + str(mxfd['l']) + ',' + str(mxfd['r'])
# convert font size in mm to percentage for d.text
mxfmm = dictomm(mxfd, dpioption)
maintitlesize = float(maintitlesize) / (mxfmm['b'] -
mxfmm['t']) * 100.0
subtitlesize = float(subtitlesize) / (mxfmm['b'] - mxfmm['t']) * 100.0
pssize = float(pssize) / (mxfmm['r'] - mxfmm['l']) * 100.0
# subtitle location is another issue
subtitletoppercent = 100.0 - subtitletop / \
(mxfmm['b'] - mxfmm['t']) * 100.0
titletoppercent = 100.0 - titletop / \
(mxfmm['b'] - mxfmm['t']) * 100.0
mapul = getmapUL(options['mapupperleft'], options['layunits'])
mapulindots = dictodots(mapul, dpioption)
mapsizes = getmapsizes(options['mapsize'], options['layunits'])
mapsizesindots = dictodots(mapsizes, dpioption)
# Correcting map area ratio to ratio of region edges
# OR screen window edges depeding on "regionmode"
# for later: grass.use_temp_region()
ISLATLONG = False
s = grass.read_command("g.region", flags='p')
kv = grass.parse_key_val(s, sep=':')
regioncols = float(kv['cols'].strip())
regionrows = float(kv['rows'].strip())
ewrestemp = kv['ewres'].strip()
nsrestemp = kv['nsres'].strip()
if ewrestemp.find(':') > 0:
ISLATLONG = True
ewrestemp = ewrestemp.split(':')
ewres = float(ewrestemp[0]) + float(ewrestemp[1]) / 60.0 + float(
ewrestemp[2]) / 3600.0
nsrestemp = nsrestemp.split(':')
nsres = float(nsrestemp[0]) + float(nsrestemp[1]) / 60.0 + float(
nsrestemp[2]) / 3600.0
else:
ewres = float(ewrestemp)
nsres = float(nsrestemp)
sizex = regioncols * ewres
sizey = regionrows * nsres
grass.verbose(_("printws: sizex " + str(sizex)))
grass.verbose(_("printws: sizey " + str(sizey)))
if regionmode == 'region':
hregionratio = float(sizex) / float(sizey)
grass.verbose(_("printws: REGION MODE -> region "))
else: # surprisingly doing the SAME
# using screen window ratio for map area
# next line was a test for this but didn't help on gadgets positioning
#hregionratio = float(extents[8]) / float(extents[9])
hregionratio = float(sizex) / float(sizey)
grass.verbose(_("printws: REGION MODE -> window"))
hmapratio = mapsizes['w'] / mapsizes['h']
grass.verbose(_("printws: raw mapsizes: " + str(mapsizesindots)))
grass.verbose(_("printws: hr: " + str(hregionratio)))
grass.verbose(_("printws: hm: " + str(hmapratio)))
if hregionratio > hmapratio:
grass.verbose(
_("printws: Map area height correction / " +
str(hregionratio)))
mapsizes['h'] = mapsizes['w'] / hregionratio
elif hregionratio < hmapratio:
grass.verbose(
_("printws: Map area width correction * " + str(hregionratio)))
mapsizes['w'] = mapsizes['h'] * hregionratio
mapsizesindots = dictodots(mapsizes, dpioption)
# changing region resolution to match print resolution
# to eliminate unnecessary CPU heating/data transfer
# so as to make it faster
# with only invisible detail loss.
colsregiontomap = float(mapsizesindots['w']) / regioncols
rowsregiontomap = float(mapsizesindots['h']) / regionrows
newewres = ewres
newnsres = nsres
# if colsregiontomap < 1:
# CHANGE: also enables raising of resolution to prevent
# pixelation because of low resolution setting...
newewres = ewres / colsregiontomap
# if rowsregiontomap < 1:
newnsres = nsres / rowsregiontomap
# WOW - no necessary to convert back to DMS for nsres / ewres
#if ISLATLONG:
# newewresstr=decdeg2dms(newewres)
# newnsresstr=decdeg2dms(newnsres)
#else:
newewresstr = str(newewres)
newnsresstr = str(newnsres)
grass.run_command("g.region", ewres=newewresstr, nsres=newnsresstr)
# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
# it seems that d.wms uses the GRASS_REGION from region info
# others may also do so we set it
# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
kv2 = {}
kv2['e'] = kv['east']
kv2['n'] = kv['north']
kv2['s'] = kv['south']
kv2['w'] = kv['west']
kv2['ewres'] = newewresstr
kv2['nsres'] = newnsresstr
#kv2['rows'] #- autocalculated to resolution - no need to set explicitly
#kv2['cols'] #- autocalculated to resolution - no need to set explicitly
#grass.message(str(kv2))
#grass.message(grass.region_env(**kv2))
#grass.message(s)
os.environ['GRASS_REGION'] = grass.region_env(**kv2)
# Getting mapping area in dots
# Correcting mxfd to leave space for title and subscript
pagemarginstitles = copy.deepcopy(pagemargins)
pagemarginstitles['t'] = pagemarginstitles['t'] + upperspace
pagemarginstitles['b'] = pagemarginstitles['b'] + lowerspace
pagemarginsindotstitles = dictodots(pagemarginstitles, dpioption)
mxfdtitles = getmaxframeindots(pagemarginsindotstitles,
pagesizesindots)
mpfd = getmapframeindots(mapulindots, mapsizesindots, mxfdtitles)
if pageoption == 'Flexi':
# For 'Flexi' page we modify the setup to create
# a page containing only the map without margins
grass.verbose(_("printws: pre Flexi mapframe: " + str(mpfd)))
mpfd['b'] = mpfd['b'] - mpfd['t']
mpfd['t'] = 0
mpfd['r'] = mpfd['r'] - mpfd['l']
mpfd['l'] = 0
os.environ['GRASS_RENDER_WIDTH'] = str(mpfd['r'])
os.environ['GRASS_RENDER_HEIGHT'] = str(mpfd['b'])
grass.verbose(_("printws: post Flexi mapframe: " + str(mpfd)))
mapframe = str(mpfd['t']) + ',' + str(mpfd['b']) + \
',' + str(mpfd['l']) + ',' + str(mpfd['r'])
grass.verbose(_("printws: DOT VALUES ARE:"))
grass.verbose(_("printws: maxframe: " + str(mxfd)))
grass.verbose(_("printws: maxframe: " + maxframe))
grass.verbose(_("printws: mapframe: " + str(mpfd)))
grass.verbose(_("printws: mapframe: " + mapframe))
grass.verbose(_("printws: page: " + str(pagesizesindots)))
grass.verbose(_("printws: margins: " + str(pagemarginsindots)))
grass.verbose(_("printws: mapUL: " + str(mapulindots)))
grass.verbose(
_("printws: mapsizes (corrected): " + str(mapsizesindots)))
grass.verbose(_("printws: ewres (corrected): " + str(newewres)))
grass.verbose(_("printws: nsres (corrected): " + str(newnsres)))
# quit()
# ------------------- INMAP -------------------
# Do not limit -map. It was: -limit map 720000000 before...
# So we can grow on disk as long as it lasts
imcommand = 'convert -limit memory 720000000 -units PixelsPerInch -density ' + \
str(int(dpioption)) + ' '
if os.name == 'nt':
imcommand = 'magick ' + imcommand
os.environ['GRASS_RENDER_FRAME'] = mapframe
grass.verbose(_("printws: Rendering: the following layers: "))
lastopacity = '-1'
for lay in layers:
grass.verbose(_(lay[1] + ' at: ' + lay[0] + ' opacity'))
if lay[0] == '1':
if lastopacity <> '1':
LASTFILE = os.path.join(TMPDIR, str(os.getpid()) + \
'_DIS_' + str(displaycounter) + '_GEN_' + \
str(LAYERCOUNT) + '.' + TMPFORMAT)
os.environ['GRASS_RENDER_FILE'] = LASTFILE
LAYERCOUNT = LAYERCOUNT + 2
imcommand = imcommand + ' ' + LASTFILE
lastopacity = '1'
render(lay[1], lay[2], lay[3])
else:
lastopacity = lay[0]
LASTFILE = os.path.join(
TMPDIR,
str(os.getpid()) + '_DIS_' + str(displaycounter) +
'_GEN_' + str(LAYERCOUNT) + '.' + TMPFORMAT)
LAYERCOUNT = LAYERCOUNT + 2
os.environ['GRASS_RENDER_FILE'] = LASTFILE
grass.verbose("LAY: " + str(lay))
render(lay[1], lay[2], lay[3])
imcommand = imcommand + \
' \( ' + LASTFILE + ' -channel a -evaluate multiply ' + \
lay[0] + ' +channel \)'
# setting resolution back to pre-script state since map rendering is
# finished
# CHANGE: not necessary anymore since we use temp_region now
# However, since we did set GRASS_REGION, let's redo it here
os.environ.pop('GRASS_REGION')
# ------------------- OUTSIDE MAP texts, etc -------------------
if pageoption == 'Flexi':
grass.verbose(
_('m.printws: WARNING! Felxi mode, will not create titles, etc...'
))
else:
os.environ['GRASS_RENDER_FRAME'] = maxframe
dict = {}
dict['task'] = "d.text"
dict['color'] = titlecolor
dict['font'] = titlefont
dict['charset'] = "UTF-8"
if len(options['maintitle']) > 1:
dict['text'] = decodetextmacros(options['maintitle'],
textmacros)
dict['at'] = "50," + str(titletoppercent)
dict['align'] = "uc"
dict['size'] = str(maintitlesize)
render(str(dict), dict, {})
if len(options['subtitle']) > 1:
dict['text'] = decodetextmacros(options['subtitle'],
textmacros)
dict['at'] = "50," + str(subtitletoppercent)
dict['align'] = "uc"
dict['size'] = str(subtitlesize)
render(str(dict), dict, {})
dict['size'] = str(pssize)
if len(options['psundercentral']) > 1:
dict['text'] = decodetextmacros(options['psundercentral'],
textmacros)
dict['at'] = "50,1"
dict['align'] = "lc"
render(str(dict), dict, {})
if len(options['psunderleft']) > 1:
dict['text'] = decodetextmacros(options['psunderleft'],
textmacros)
dict['at'] = "0,1"
dict['align'] = "ll"
render(str(dict), dict, {})
if len(options['psunderright']) > 1:
dict['text'] = decodetextmacros(options['psunderright'],
textmacros)
dict['at'] = "100,1"
dict['align'] = "lr"
render(str(dict), dict, {})
# ------------------- GENERATING OUTPUT FILE -------------------
if len(options['output']) > 1:
output = options['output']
else:
output = 'map_' + str(os.getpid())
# remove extension AND display number and naming if any
output = os.path.splitext(output)[0]
output = re.sub('_DISPLAY_[0-9]+_.*', '', output)
if len(options['format']) > 1:
extension = options['format']
else:
extension = 'pdf'
displaypart = ''
if len(displays) > 1:
displaypart = '_DISPLAY_' + str(displaycounter) + '_' + key
pagedata = getpagedata(pageoption)
#params= ' -extent '+str(pagesizesindots['w'])+'x'+str(pagesizesindots['h'])+' -gravity center -compress jpeg -page '+pagedata['page']+' '+pagedata['parameters']+' -units PixelsPerInch -density '+str(dpioption)+'x'+str(dpioption)+' '
params = ' -compress jpeg -quality 92 ' + \
pagedata['parameters'] + ' -units PixelsPerInch -density ' + \
str(int(dpioption)) + ' '
imcommand = imcommand + ' -layers flatten ' + params + \
'"' + output + displaypart + '.' + extension + '"'
grass.verbose(
_('printws: And the imagemagick command is... ' + imcommand))
os.system(imcommand)
if not flags['d']:
grass.verbose(_('printws: Doing graceful cleanup...'))
os.system('rm ' + os.path.join(TMPDIR, str(os.getpid()) + '*_GEN_*'))
if REMOVE_TMPDIR:
try_rmdir(TMPDIR)
else:
grass.message(
"\n%s\n" %
_("printws: Temp dir remove failed. Do it yourself, please:"))
sys.stderr.write('%s\n' % TMPDIR % ' <---- this')
# restoring pre-script region
# - not necessary as we are using grass.use_temp_region() in the future
return 0
def ImportMapIntoGRASS(self, raster):
"""!Import raster into GRASS."""
# importing temp_map into GRASS
try:
# do not use -o flag !
grass.run_command(
"r.in.gdal",
flags="o",
quiet=True,
overwrite=True,
input=raster,
output=self.opt_output,
)
except CalledModuleError:
grass.fatal(_("%s failed") % "r.in.gdal")
# information for destructor to cleanup temp_layers, created
# with r.in.gdal
# setting region for full extend of imported raster
if grass.find_file(self.opt_output + ".red", element="cell", mapset=".")[
"file"
]:
region_map = self.opt_output + ".red"
else:
region_map = self.opt_output
os.environ["GRASS_REGION"] = grass.region_env(rast=region_map)
# mask created from alpha layer, which describes real extend
# of warped layer (may not be a rectangle), also mask contains
# transparent parts of raster
if grass.find_file(self.opt_output + ".alpha", element="cell", mapset=".")[
"name"
]:
# saving current mask (if exists) into temp raster
if grass.find_file("MASK", element="cell", mapset=".")["name"]:
try:
mask_copy = self.opt_output + self.original_mask_suffix
grass.run_command("g.copy", quiet=True, raster="MASK," + mask_copy)
except CalledModuleError:
grass.fatal(_("%s failed") % "g.copy")
# info for destructor
self.cleanup_mask = True
try:
grass.run_command(
"r.mask",
quiet=True,
overwrite=True,
maskcats="0",
flags="i",
raster=self.opt_output + ".alpha",
)
except CalledModuleError:
grass.fatal(_("%s failed") % "r.mask")
if not self.cleanup_bands:
# use the MASK to set NULL vlues
for suffix in (".red", ".green", ".blue"):
rast = self.opt_output + suffix
if grass.find_file(rast, element="cell", mapset=".")["file"]:
grass.run_command(
"g.rename",
rast="%s,%s" % (rast, rast + "_null"),
quiet=True,
)
grass.run_command(
"r.mapcalc",
expression="%s = %s" % (rast, rast + "_null"),
quiet=True,
)
grass.run_command(
"g.remove",
type="raster",
name="%s" % (rast + "_null"),
flags="f",
quiet=True,
)
# TODO one band + alpha band?
if (
grass.find_file(self.opt_output + ".red", element="cell", mapset=".")[
"file"
]
and self.cleanup_bands
):
try:
grass.run_command(
"r.composite",
quiet=True,
overwrite=True,
red=self.opt_output + ".red",
green=self.opt_output + ".green",
blue=self.opt_output + ".blue",
output=self.opt_output,
)
except CalledModuleError:
grass.fatal(_("%s failed") % "r.composite")
def main():
options, flags = gs.parser()
simulated = options["simulated"]
original = options["original"]
reference = options["reference"]
kappa = options["kappa"]
kappasimulation = options["kappasimulation"]
quantity_disagreement = options["quantity_disagreement"]
allocation_disagreement = options["allocation_disagreement"]
quantity_disagreement_basename = options["quantity_disagreement_basename"]
allocation_disagreement_basename = options[
"allocation_disagreement_basename"]
input_region = options["region"]
nprocs = int(options["nprocs"])
current = gs.region()
region = gs.parse_command("g.region", flags="pug", region=input_region)
regions = []
for row in range(int(region["rows"])):
for col in range(int(region["cols"])):
s = float(region["s"]) + row * float(region["nsres"])
n = float(region["s"]) + (row + 1) * float(region["nsres"])
w = float(region["w"]) + col * float(region["ewres"])
e = float(region["w"]) + (col + 1) * float(region["ewres"])
regions.append({
"n": n,
"s": s,
"w": w,
"e": e,
"nsres": float(current["nsres"]),
"ewres": float(current["ewres"]),
})
results = []
params = []
for each in regions:
if original:
params.append({
"region": each,
"simulated": simulated,
"reference": reference,
"original": original,
})
else:
params.append({
"region": each,
"simulated": simulated,
"reference": reference
})
with Pool(processes=nprocs) as pool:
results = pool.map_async(compute, params).get()
outputs = {}
if kappa:
outputs["kappa"] = {"name": kappa, "param": "kappa", "inp": ""}
if kappasimulation:
outputs["kappasim"] = {
"name": kappasimulation,
"param": "kappasimulation",
"inp": "",
}
if quantity_disagreement:
outputs["quantity_disagreement"] = {
"name": quantity_disagreement,
"param": "total_quantity",
"inp": "",
}
if allocation_disagreement:
outputs["allocation_disagreement"] = {
"name": allocation_disagreement,
"param": "total_allocation",
"inp": "",
}
env = os.environ.copy()
env["GRASS_REGION"] = gs.region_env(region=input_region)
for r in results:
for key in r.keys():
if allocation_disagreement_basename and "allocation_class_" in key:
cl = key.replace("allocation_class_", "")
if cl not in outputs:
outputs[cl] = {
"name": allocation_disagreement_basename + "_" + cl,
"param": key,
"inp": "",
}
if quantity_disagreement_basename and "quantity_class_" in key:
cl = key.replace("quantity_class_", "")
if cl not in outputs:
outputs[cl] = {
"name": quantity_disagreement_basename + "_" + cl,
"param": key,
"inp": "",
}
for k in outputs:
if outputs[k]["param"] in r and r[outputs[k]["param"]] is not None:
outputs[k][
"inp"] += f"{r['e']},{r['n']},{r[outputs[k]['param']]}\n"
for k in outputs:
gs.write_command(
"r.in.xyz",
input="-",
stdin=outputs[k]["inp"],
output=outputs[k]["name"],
method="mean",
separator="comma",
env=env,
quiet=True,
)
gs.raster_history(outputs[k]["name"])
def function(pa):
pa0 = 'v0_'+pa
os.environ['GRASS_REGION'] = grass.region_env(vect=pa0,res=1000)
#grass. message("omitting previous masks")
grass.run_command('g.remove', rast='MASK')
if pa not in pa_list_done:
opt1 = 'wdpa_id = '+pa
#print px
#print "Extracting PA:"+pa
#grass.run_command('v.extract', input=source, out=pa0, where = opt1,overwrite=True)
pa2 = pa+'v2'
pa3 = pa+'v3'
pa4 = 'paa_'+pa
pa44 = 'pa_'+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.mask', vector=source, where=opt1)
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]
#grass.run_command('g.remove', rast='MASK')
#print a
minarea = np.sqrt(int(a[1]))#/1000
#print minarea
#grass. message ("segmenting the park")
grass.run_command('i.segment', group='segm', output=pa2, threshold='0.7', method='region_growing', similarity='euclidean', minsize=minarea, memory='100000', iterations='20',overwrite=True)
#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.remove', rast='MASK')
#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 VARCHAR')
grass.run_command('v.db.update', map=pa4,col='wdpaid',value=pa)
#grass. message ("Checking shapefile")
grass.run_command('v.clean', input=pa4,out=pa44,tool='rmarea',thres=minarea,overwrite=True)
grass.run_command('v.db.addcolumn', map=pa44,col='wdpa_id VARCHAR')
grass.run_command('v.db.update', map=pa44,col='wdpa_id',qcol='wdpaid || cat')
#grass. message ("Exporting shapefile")
#if pa == 0:
# grass.run_command('v.out.ogr',input=pa44,ola='parks_segmented',dsn='.')
#else:
grass.run_command('v.out.ogr',flags='a',input=pa44,ola='parks_segmented2',dsn='.')
#grass. message ("Deleting tmp layers")
#grass.run_command('g.mremove',rast='*v3',flags='f')
#grass.run_command('g.mremove',rast='*v2',flags='f')
#grass.run_command('g.mremove',rast='v0_*',flags='f')
#grass.run_command('g.mremove',rast='pa_*',flags='f')
#grass.run_command('g.mremove',vect='v0_*',flags='f')
##grass.run_command('g.mremove',vect='pa_*',flags='f')
#grass.run_command('g.mremove',vect='paa_*',flags='f')
#grass. message ("Done")
print "Done PA:"+pa
wb = open(csvname1,'a')
var = str(pa)
wb.write(var)
wb.write('\n')
wb.close()
os.environ.pop('GRASS_REGION')
def do_it_all(global_vars, target_pts_np):
"""Conduct weighted and parametrised partial viewshed and cummulate it with
the previous partial viewsheds
:param target_pts_np: Array of target points in global coordinate system
:type target_pts_np: ndarray
:return: 2D array of weighted parametrised cummulative viewshed
:rtype: ndarray
"""
# Set counter
counter = 1
# Get variables out of global_vars dictionary
reg = global_vars["region"]
exp_range = global_vars["range"]
flagstring = global_vars["flagstring"]
r_dsm = global_vars["r_dsm"]
v_elevation = global_vars["observer_elevation"]
refr_coeff = global_vars["refr_coeff"]
memory = global_vars["memory"]
parametrise_viewshed = global_vars["param_viewshed"]
dsm_type = global_vars["dsm_type"]
b_1 = global_vars["b_1"]
cores = global_vars["cores"]
tempname = global_vars["tempname"]
# Create empty viewshed
np_cum = np.empty((reg.rows, reg.cols), dtype=np.single)
np_cum[:] = np.nan
tmp_vs = "{}_{}".format(tempname, os.getpid())
for target_pnt in target_pts_np:
# Display a progress info message
grass.percent(counter, len(target_pts_np), 1)
grass.verbose("Processing point {i} ({p:.1%})".format(
i=int(target_pnt[0]), p=counter / len(target_pts_np)))
# Global coordinates and attributes of target point T
t_glob = target_pnt[1:]
# ======================================================================
# 1. Set local computational region: +/- exp_range from target point
# ======================================================================
# compute position of target point within a pixel
delta_n = math.ceil(
(t_glob[1] - reg.south) / reg.nsres) * reg.nsres - (t_glob[1] -
reg.south)
delta_s = (t_glob[1] - reg.south) - math.floor(
(t_glob[1] - reg.south) / reg.nsres) * reg.nsres
delta_e = math.ceil(
(t_glob[0] - reg.west) / reg.ewres) * reg.ewres - (t_glob[0] -
reg.west)
delta_w = (t_glob[0] - reg.west) - math.floor(
(t_glob[0] - reg.west) / reg.ewres) * reg.ewres
# ensure that local region doesn't exceed global region
loc_reg_n = min(t_glob[1] + exp_range + delta_n, reg.north)
loc_reg_s = max(t_glob[1] - exp_range - delta_s, reg.south)
loc_reg_e = min(t_glob[0] + exp_range + delta_e, reg.east)
loc_reg_w = max(t_glob[0] - exp_range - delta_w, reg.west)
# pygrass sets region for pygrass tasks
lreg = deepcopy(reg)
lreg.set_bbox(Bbox(loc_reg_n, loc_reg_s, loc_reg_e, loc_reg_w))
lreg.set_raster_region()
# Create processing environment with region information
c_env = os.environ.copy()
c_env["GRASS_REGION"] = grass.region_env(n=loc_reg_n,
s=loc_reg_s,
e=loc_reg_e,
w=loc_reg_w)
lreg_shape = [lreg.rows, lreg.cols]
# ======================================================================
# 2. Calculate binary viewshed and convert to numpy
# ======================================================================
vs = grass.pipe_command(
"r.viewshed",
flags="b" + flagstring,
input=r_dsm,
output=tmp_vs,
coordinates="{},{}".format(t_glob[0], t_glob[1]),
observer_elevation=0.0,
target_elevation=v_elevation,
max_distance=exp_range,
refraction_coeff=refr_coeff,
memory=int(round(memory / cores)),
quiet=True,
overwrite=True,
env=c_env,
)
vs.communicate()
# Workaround for https://github.com/OSGeo/grass/issues/1436
clean_temp(vs.pid)
# Read viewshed into numpy with single precision and replace NoData
np_viewshed = raster2numpy(tmp_vs).astype(np.single)
np_viewshed[np_viewshed == -2147483648] = np.nan
# ======================================================================
# 3. Prepare local coordinates and attributes of target point T
# ======================================================================
# Calculate how much of rows/cols of local region lies
# outside global region
o_1 = [
max(t_glob[1] + exp_range + reg.nsres / 2 - reg.north, 0),
max(reg.west - (t_glob[0] - exp_range - reg.ewres / 2), 0),
]
t_loc = np.append(
np.array([
exp_range / reg.nsres + 0.5 - o_1[0] / reg.nsres,
exp_range / reg.ewres + 0.5 - o_1[1] / reg.ewres,
]),
t_glob[2:],
)
# ======================================================================
# 4. Parametrise viewshed
# ======================================================================
np_viewshed = parametrise_viewshed(
lreg_shape,
t_loc,
np_viewshed,
reg,
exp_range,
r_dsm,
dsm_type,
v_elevation,
b_1,
).astype(np.single)
# ======================================================================
# 5. Cummulate viewsheds
# ======================================================================
# Determine position of local parametrised viewshed within
# global cummulative viewshed
o_2 = [
int(round((reg.north - loc_reg_n) / reg.nsres)), # NS (rows)
int(round((loc_reg_w - reg.west) / reg.ewres)), # EW (cols)
]
# Add local parametrised viewshed to global cummulative viewshed
# replace nans with 0 in processed regions, keep nan where both are nan
all_nan = np.all(
np.isnan([
np_cum[o_2[0]:o_2[0] + lreg_shape[0],
o_2[1]:o_2[1] + lreg_shape[1]],
np_viewshed,
]),
axis=0,
)
np_cum[o_2[0]:o_2[0] + lreg_shape[0],
o_2[1]:o_2[1] + lreg_shape[1]] = np.nansum(
[
np_cum[o_2[0]:o_2[0] + lreg_shape[0],
o_2[1]:o_2[1] + lreg_shape[1]],
np_viewshed,
],
axis=0,
)
np_cum[o_2[0]:o_2[0] + lreg_shape[0],
o_2[1]:o_2[1] + lreg_shape[1]][all_nan] = np.nan
counter += 1
return np_cum
def main():
"""
Gridded flexural isostatic solutions
"""
options, flags = grass.parser()
# if just interface description is requested, it will not get to this point
# so gflex will not be needed
# GFLEX
# try to import gflex only after we know that
# we will actually do the computation
try:
import gflex
except:
print("")
print("MODULE IMPORT ERROR.")
print("In order to run r.flexure or g.flexure, you must download and install")
print("gFlex. The most recent development version is available from")
print("https://github.com/awickert/gFlex.")
print("Installation instructions are available on the page.")
grass.fatal("Software dependency must be installed.")
# This code is for 2D flexural isostasy
flex = gflex.F2D()
# And show that it is coming from GRASS GIS
flex.grass = True
# Flags
latlon_override = flags["l"]
# Inputs
# Solution selection
flex.Method = options["method"]
if flex.Method == "FD":
flex.Solver = options["solver"]
if flex.Solver:
flex.ConvergenceTolerance = options["tolerance"]
# Always use the van Wees and Cloetingh (1994) solution type.
# It is the best.
flex.PlateSolutionType = "vWC1994"
# Parameters that are often changed for the solution
qs = options["input"]
flex.qs = garray.array()
flex.qs.read(qs)
# Elastic thickness
try:
flex.Te = float(options["te"])
except:
flex.Te = garray.array() # FlexureTe is the one that is used by Flexure
flex.Te.read(options["te"])
flex.Te = np.array(flex.Te)
if options["te_units"] == "km":
flex.Te *= 1000
elif options["te_units"] == "m":
pass
# No "else"; shouldn't happen
flex.rho_fill = float(options["rho_fill"])
# Parameters that often stay at their default values
flex.g = float(options["g"])
flex.E = float(
options["ym"]
) # Can't just use "E" because reserved for "east", I think
flex.nu = float(options["nu"])
flex.rho_m = float(options["rho_m"])
# Solver type and iteration tolerance
flex.Solver = options["solver"]
flex.ConvergenceTolerance = float(options["tolerance"])
# Boundary conditions
flex.BC_N = options["northbc"]
flex.BC_S = options["southbc"]
flex.BC_W = options["westbc"]
flex.BC_E = options["eastbc"]
# Set verbosity
if grass.verbosity() >= 2:
flex.Verbose = True
if grass.verbosity() >= 3:
flex.Debug = True
elif grass.verbosity() == 0:
flex.Quiet = True
# First check if output exists
if len(grass.parse_command("g.list", type="rast", pattern=options["output"])):
if not grass.overwrite():
grass.fatal(
"Raster map '"
+ options["output"]
+ "' already exists. Use '--o' to overwrite."
)
# Get grid spacing from GRASS
# Check if lat/lon and proceed as directed
if grass.region_env()[6] == "3":
if latlon_override:
if flex.Verbose:
print("Latitude/longitude grid.")
print("Based on r_Earth = 6371 km")
print("Setting y-resolution [m] to 111,195 * [degrees]")
flex.dy = grass.region()["nsres"] * 111195.0
NSmid = (grass.region()["n"] + grass.region()["s"]) / 2.0
dx_at_mid_latitude = (
(3.14159 / 180.0) * 6371000.0 * np.cos(np.deg2rad(NSmid))
)
if flex.Verbose:
print(
"Setting x-resolution [m] to "
+ "%.2f" % dx_at_mid_latitude
+ " * [degrees]"
)
flex.dx = grass.region()["ewres"] * dx_at_mid_latitude
else:
grass.fatal("Need the '-l' flag to enable lat/lon solution approximation.")
# Otherwise straightforward
else:
flex.dx = grass.region()["ewres"]
flex.dy = grass.region()["nsres"]
# CALCULATE!
flex.initialize()
flex.run()
flex.finalize()
# Write to GRASS
# Create a new garray buffer and write to it
outbuffer = garray.array() # Instantiate output buffer
outbuffer[...] = flex.w
outbuffer.write(
options["output"], overwrite=grass.overwrite()
) # Write it with the desired name
# And create a nice colormap!
grass.run_command(
"r.colors", map=options["output"], color="differences", quiet=True
)
def ImportMapIntoGRASS(self, raster):
"""!Import raster into GRASS.
"""
# importing temp_map into GRASS
try:
# do not use -o flag !
grass.run_command('r.in.gdal',
flags='o',
quiet=True,
overwrite=True,
input=raster,
output=self.opt_output)
except CalledModuleError:
grass.fatal(_('%s failed') % 'r.in.gdal')
# information for destructor to cleanup temp_layers, created
# with r.in.gdal
# setting region for full extend of imported raster
if grass.find_file(self.opt_output + '.red',
element='cell',
mapset='.')['file']:
region_map = self.opt_output + '.red'
else:
region_map = self.opt_output
os.environ['GRASS_REGION'] = grass.region_env(rast=region_map)
# mask created from alpha layer, which describes real extend
# of warped layer (may not be a rectangle), also mask contains
# transparent parts of raster
if grass.find_file(self.opt_output + '.alpha',
element='cell',
mapset='.')['name']:
# saving current mask (if exists) into temp raster
if grass.find_file('MASK', element='cell', mapset='.')['name']:
try:
mask_copy = self.opt_output + self.original_mask_suffix
grass.run_command('g.copy',
quiet=True,
raster='MASK,' + mask_copy)
except CalledModuleError:
grass.fatal(_('%s failed') % 'g.copy')
# info for destructor
self.cleanup_mask = True
try:
grass.run_command('r.mask',
quiet=True,
overwrite=True,
maskcats="0",
flags='i',
raster=self.opt_output + '.alpha')
except CalledModuleError:
grass.fatal(_('%s failed') % 'r.mask')
if not self.cleanup_bands:
# use the MASK to set NULL vlues
for suffix in ('.red', '.green', '.blue'):
rast = self.opt_output + suffix
if grass.find_file(rast, element='cell',
mapset='.')['file']:
grass.run_command('g.rename',
rast='%s,%s' %
(rast, rast + '_null'),
quiet=True)
grass.run_command('r.mapcalc',
expression='%s = %s' %
(rast, rast + '_null'),
quiet=True)
grass.run_command('g.remove',
type='raster',
name='%s' % (rast + '_null'),
flags='f',
quiet=True)
# TODO one band + alpha band?
if grass.find_file(self.opt_output + '.red',
element='cell',
mapset='.')['file'] and self.cleanup_bands:
try:
grass.run_command('r.composite',
quiet=True,
overwrite=True,
red=self.opt_output + '.red',
green=self.opt_output + '.green',
blue=self.opt_output + '.blue',
output=self.opt_output)
except CalledModuleError:
grass.fatal(_('%s failed') % 'r.composite')
def main():
global TMPLOC, SRCGISRC, GISDBASE, TMP_REG_NAME
GDALdatasource = options['input']
output = options['output']
method = options['resample']
memory = options['memory']
bands = options['band']
tgtres = options['resolution']
title = options["title"]
if flags['e'] and not output:
output = 'rimport_tmp' # will be removed with the entire tmp location
if options['resolution_value']:
if tgtres != 'value':
grass.fatal(
_("To set custom resolution value, select 'value' in resolution option"
))
tgtres_value = float(options['resolution_value'])
if tgtres_value <= 0:
grass.fatal(_("Resolution value can't be smaller than 0"))
elif tgtres == 'value':
grass.fatal(
_("Please provide the resolution for the imported dataset or change to 'estimated' resolution"
))
# try r.in.gdal directly first
additional_flags = 'l' if flags['l'] else ''
if flags['o']:
additional_flags += 'o'
region_flag = ''
if options['extent'] == 'region':
region_flag += 'r'
if flags['o'] or is_projection_matching(GDALdatasource):
parameters = dict(input=GDALdatasource,
output=output,
memory=memory,
flags='ak' + additional_flags + region_flag)
if bands:
parameters['band'] = bands
try:
grass.run_command('r.in.gdal', **parameters)
grass.verbose(
_("Input <%s> successfully imported without reprojection") %
GDALdatasource)
return 0
except CalledModuleError as e:
grass.fatal(
_("Unable to import GDAL dataset <%s>") % GDALdatasource)
grassenv = grass.gisenv()
tgtloc = grassenv['LOCATION_NAME']
# make sure target is not xy
if grass.parse_command('g.proj',
flags='g')['name'] == 'xy_location_unprojected':
grass.fatal(
_("Coordinate reference system not available for current location <%s>"
) % tgtloc)
tgtmapset = grassenv['MAPSET']
GISDBASE = grassenv['GISDBASE']
TMPLOC = grass.append_node_pid("tmp_r_import_location")
TMP_REG_NAME = grass.append_node_pid("tmp_r_import_region")
SRCGISRC, src_env = grass.create_environment(GISDBASE, TMPLOC, 'PERMANENT')
# create temp location from input without import
grass.verbose(
_("Creating temporary location for <%s>...") % GDALdatasource)
# creating a new location with r.in.gdal requires a sanitized env
env = os.environ.copy()
env = grass.sanitize_mapset_environment(env)
parameters = dict(input=GDALdatasource,
output=output,
memory=memory,
flags='c',
title=title,
location=TMPLOC,
quiet=True)
if bands:
parameters['band'] = bands
try:
grass.run_command('r.in.gdal', env=env, **parameters)
except CalledModuleError:
grass.fatal(_("Unable to read GDAL dataset <%s>") % GDALdatasource)
# prepare to set region in temp location
if 'r' in region_flag:
tgtregion = TMP_REG_NAME
grass.run_command('v.in.region', output=tgtregion, flags='d')
# switch to temp location
# print projection at verbose level
grass.verbose(
grass.read_command('g.proj', flags='p',
env=src_env).rstrip(os.linesep))
# make sure input is not xy
if grass.parse_command('g.proj', flags='g',
env=src_env)['name'] == 'xy_location_unprojected':
grass.fatal(
_("Coordinate reference system not available for input <%s>") %
GDALdatasource)
# import into temp location
grass.verbose(
_("Importing <%s> to temporary location...") % GDALdatasource)
parameters = dict(input=GDALdatasource,
output=output,
memory=memory,
flags='ak' + additional_flags)
if bands:
parameters['band'] = bands
if 'r' in region_flag:
grass.run_command('v.proj',
location=tgtloc,
mapset=tgtmapset,
input=tgtregion,
output=tgtregion,
env=src_env)
grass.run_command('g.region', vector=tgtregion, env=src_env)
parameters['flags'] = parameters['flags'] + region_flag
try:
grass.run_command('r.in.gdal', env=src_env, **parameters)
except CalledModuleError:
grass.fatal(_("Unable to import GDAL dataset <%s>") % GDALdatasource)
outfiles = grass.list_grouped('raster', env=src_env)['PERMANENT']
# is output a group?
group = False
path = os.path.join(GISDBASE, TMPLOC, 'group', output)
if os.path.exists(path):
group = True
path = os.path.join(GISDBASE, TMPLOC, 'group', output, 'POINTS')
if os.path.exists(path):
grass.fatal(_("Input contains GCPs, rectification is required"))
if 'r' in region_flag:
grass.run_command('g.remove',
type="vector",
flags="f",
name=tgtregion,
env=src_env)
# switch to target location
if 'r' in region_flag:
grass.run_command('g.remove', type="vector", flags="f", name=tgtregion)
region = grass.region()
rflags = None
if flags['n']:
rflags = 'n'
vreg = TMP_REG_NAME
for outfile in outfiles:
n = region['n']
s = region['s']
e = region['e']
w = region['w']
env = os.environ.copy()
if options['extent'] == 'input':
# r.proj -g
try:
tgtextents = grass.read_command('r.proj',
location=TMPLOC,
mapset='PERMANENT',
input=outfile,
flags='g',
memory=memory,
quiet=True)
except CalledModuleError:
grass.fatal(_("Unable to get reprojected map extent"))
try:
srcregion = grass.parse_key_val(tgtextents,
val_type=float,
vsep=' ')
n = srcregion['n']
s = srcregion['s']
e = srcregion['e']
w = srcregion['w']
except ValueError: # import into latlong, expect 53:39:06.894826N
srcregion = grass.parse_key_val(tgtextents, vsep=' ')
n = grass.float_or_dms(srcregion['n'][:-1]) * \
(-1 if srcregion['n'][-1] == 'S' else 1)
s = grass.float_or_dms(srcregion['s'][:-1]) * \
(-1 if srcregion['s'][-1] == 'S' else 1)
e = grass.float_or_dms(srcregion['e'][:-1]) * \
(-1 if srcregion['e'][-1] == 'W' else 1)
w = grass.float_or_dms(srcregion['w'][:-1]) * \
(-1 if srcregion['w'][-1] == 'W' else 1)
env['GRASS_REGION'] = grass.region_env(n=n, s=s, e=e, w=w)
# v.in.region in tgt
grass.run_command('v.in.region', output=vreg, quiet=True, env=env)
# reproject to src
# switch to temp location
try:
grass.run_command('v.proj',
input=vreg,
output=vreg,
location=tgtloc,
mapset=tgtmapset,
quiet=True,
env=src_env)
# test if v.proj created a valid area
if grass.vector_info_topo(vreg, env=src_env)['areas'] != 1:
grass.fatal(_("Please check the 'extent' parameter"))
except CalledModuleError:
grass.fatal(_("Unable to reproject to source location"))
# set region from region vector
grass.run_command('g.region', raster=outfile, env=src_env)
grass.run_command('g.region', vector=vreg, env=src_env)
# align to first band
grass.run_command('g.region', align=outfile, env=src_env)
# get number of cells
cells = grass.region(env=src_env)['cells']
estres = math.sqrt((n - s) * (e - w) / cells)
# remove from source location for multi bands import
grass.run_command('g.remove',
type='vector',
name=vreg,
flags='f',
quiet=True,
env=src_env)
# switch to target location
grass.run_command('g.remove',
type='vector',
name=vreg,
flags='f',
quiet=True)
grass.message(
_("Estimated target resolution for input band <{out}>: {res}").
format(out=outfile, res=estres))
if flags['e']:
continue
env = os.environ.copy()
if options['extent'] == 'input':
env['GRASS_REGION'] = grass.region_env(n=n, s=s, e=e, w=w)
res = None
if tgtres == 'estimated':
res = estres
elif tgtres == 'value':
res = tgtres_value
grass.message(
_("Using given resolution for input band <{out}>: {res}").
format(out=outfile, res=res))
# align to requested resolution
env['GRASS_REGION'] = grass.region_env(res=res, flags='a', env=env)
else:
curr_reg = grass.region()
grass.message(
_("Using current region resolution for input band "
"<{out}>: nsres={ns}, ewres={ew}").format(
out=outfile, ns=curr_reg['nsres'], ew=curr_reg['ewres']))
# r.proj
grass.message(_("Reprojecting <%s>...") % outfile)
try:
grass.run_command('r.proj',
location=TMPLOC,
mapset='PERMANENT',
input=outfile,
method=method,
resolution=res,
memory=memory,
flags=rflags,
quiet=True,
env=env)
except CalledModuleError:
grass.fatal(_("Unable to to reproject raster <%s>") % outfile)
if grass.raster_info(outfile)['min'] is None:
grass.fatal(_("The reprojected raster <%s> is empty") % outfile)
if flags['e']:
return 0
if group:
grass.run_command('i.group', group=output, input=','.join(outfiles))
# TODO: write metadata with r.support
return 0
def main():
global TMPLOC, SRCGISRC, GISDBASE, TMP_REG_NAME
GDALdatasource = options["input"]
output = options["output"]
method = options["resample"]
memory = options["memory"]
bands = options["band"]
tgtres = options["resolution"]
title = options["title"]
if flags["e"] and not output:
output = "rimport_tmp" # will be removed with the entire tmp location
if options["resolution_value"]:
if tgtres != "value":
grass.fatal(
_("To set custom resolution value, select 'value' in resolution option"
))
tgtres_value = float(options["resolution_value"])
if tgtres_value <= 0:
grass.fatal(_("Resolution value can't be smaller than 0"))
elif tgtres == "value":
grass.fatal(
_("Please provide the resolution for the imported dataset or change to 'estimated' resolution"
))
# try r.in.gdal directly first
additional_flags = "l" if flags["l"] else ""
if flags["o"]:
additional_flags += "o"
region_flag = ""
if options["extent"] == "region":
region_flag += "r"
if flags["o"] or is_projection_matching(GDALdatasource):
parameters = dict(
input=GDALdatasource,
output=output,
memory=memory,
flags="ak" + additional_flags + region_flag,
)
if bands:
parameters["band"] = bands
try:
grass.run_command("r.in.gdal", **parameters)
grass.verbose(
_("Input <%s> successfully imported without reprojection") %
GDALdatasource)
return 0
except CalledModuleError:
grass.fatal(
_("Unable to import GDAL dataset <%s>") % GDALdatasource)
grassenv = grass.gisenv()
tgtloc = grassenv["LOCATION_NAME"]
# make sure target is not xy
if grass.parse_command("g.proj",
flags="g")["name"] == "xy_location_unprojected":
grass.fatal(
_("Coordinate reference system not available for current location <%s>"
) % tgtloc)
tgtmapset = grassenv["MAPSET"]
GISDBASE = grassenv["GISDBASE"]
TMPLOC = grass.append_node_pid("tmp_r_import_location")
TMP_REG_NAME = grass.append_node_pid("tmp_r_import_region")
SRCGISRC, src_env = grass.create_environment(GISDBASE, TMPLOC, "PERMANENT")
# create temp location from input without import
grass.verbose(
_("Creating temporary location for <%s>...") % GDALdatasource)
# creating a new location with r.in.gdal requires a sanitized env
env = os.environ.copy()
env = grass.sanitize_mapset_environment(env)
parameters = dict(
input=GDALdatasource,
output=output,
memory=memory,
flags="c",
title=title,
location=TMPLOC,
quiet=True,
)
if bands:
parameters["band"] = bands
try:
grass.run_command("r.in.gdal", env=env, **parameters)
except CalledModuleError:
grass.fatal(_("Unable to read GDAL dataset <%s>") % GDALdatasource)
# prepare to set region in temp location
if "r" in region_flag:
tgtregion = TMP_REG_NAME
grass.run_command("v.in.region", output=tgtregion, flags="d")
# switch to temp location
# print projection at verbose level
grass.verbose(
grass.read_command("g.proj", flags="p",
env=src_env).rstrip(os.linesep))
# make sure input is not xy
if (grass.parse_command("g.proj", flags="g",
env=src_env)["name"] == "xy_location_unprojected"):
grass.fatal(
_("Coordinate reference system not available for input <%s>") %
GDALdatasource)
# import into temp location
grass.verbose(
_("Importing <%s> to temporary location...") % GDALdatasource)
parameters = dict(
input=GDALdatasource,
output=output,
memory=memory,
flags="ak" + additional_flags,
)
if bands:
parameters["band"] = bands
if "r" in region_flag:
grass.run_command(
"v.proj",
location=tgtloc,
mapset=tgtmapset,
input=tgtregion,
output=tgtregion,
env=src_env,
)
grass.run_command("g.region", vector=tgtregion, env=src_env)
parameters["flags"] = parameters["flags"] + region_flag
try:
grass.run_command("r.in.gdal", env=src_env, **parameters)
except CalledModuleError:
grass.fatal(_("Unable to import GDAL dataset <%s>") % GDALdatasource)
outfiles = grass.list_grouped("raster", env=src_env)["PERMANENT"]
# is output a group?
group = False
path = os.path.join(GISDBASE, TMPLOC, "group", output)
if os.path.exists(path):
group = True
path = os.path.join(GISDBASE, TMPLOC, "group", output, "POINTS")
if os.path.exists(path):
grass.fatal(_("Input contains GCPs, rectification is required"))
if "r" in region_flag:
grass.run_command("g.remove",
type="vector",
flags="f",
name=tgtregion,
env=src_env)
# switch to target location
if "r" in region_flag:
grass.run_command("g.remove", type="vector", flags="f", name=tgtregion)
region = grass.region()
rflags = None
if flags["n"]:
rflags = "n"
vreg = TMP_REG_NAME
for outfile in outfiles:
n = region["n"]
s = region["s"]
e = region["e"]
w = region["w"]
env = os.environ.copy()
if options["extent"] == "input":
# r.proj -g
try:
tgtextents = grass.read_command(
"r.proj",
location=TMPLOC,
mapset="PERMANENT",
input=outfile,
flags="g",
memory=memory,
quiet=True,
)
except CalledModuleError:
grass.fatal(_("Unable to get reprojected map extent"))
try:
srcregion = grass.parse_key_val(tgtextents,
val_type=float,
vsep=" ")
n = srcregion["n"]
s = srcregion["s"]
e = srcregion["e"]
w = srcregion["w"]
except ValueError: # import into latlong, expect 53:39:06.894826N
srcregion = grass.parse_key_val(tgtextents, vsep=" ")
n = grass.float_or_dms(srcregion["n"][:-1]) * (
-1 if srcregion["n"][-1] == "S" else 1)
s = grass.float_or_dms(srcregion["s"][:-1]) * (
-1 if srcregion["s"][-1] == "S" else 1)
e = grass.float_or_dms(srcregion["e"][:-1]) * (
-1 if srcregion["e"][-1] == "W" else 1)
w = grass.float_or_dms(srcregion["w"][:-1]) * (
-1 if srcregion["w"][-1] == "W" else 1)
env["GRASS_REGION"] = grass.region_env(n=n, s=s, e=e, w=w)
# v.in.region in tgt
grass.run_command("v.in.region", output=vreg, quiet=True, env=env)
# reproject to src
# switch to temp location
try:
grass.run_command(
"v.proj",
input=vreg,
output=vreg,
location=tgtloc,
mapset=tgtmapset,
quiet=True,
env=src_env,
)
# test if v.proj created a valid area
if grass.vector_info_topo(vreg, env=src_env)["areas"] != 1:
grass.fatal(_("Please check the 'extent' parameter"))
except CalledModuleError:
grass.fatal(_("Unable to reproject to source location"))
# set region from region vector
grass.run_command("g.region", raster=outfile, env=src_env)
grass.run_command("g.region", vector=vreg, env=src_env)
# align to first band
grass.run_command("g.region", align=outfile, env=src_env)
# get number of cells
cells = grass.region(env=src_env)["cells"]
estres = math.sqrt((n - s) * (e - w) / cells)
# remove from source location for multi bands import
grass.run_command("g.remove",
type="vector",
name=vreg,
flags="f",
quiet=True,
env=src_env)
# switch to target location
grass.run_command("g.remove",
type="vector",
name=vreg,
flags="f",
quiet=True)
grass.message(
_("Estimated target resolution for input band <{out}>: {res}").
format(out=outfile, res=estres))
if flags["e"]:
continue
env = os.environ.copy()
if options["extent"] == "input":
env["GRASS_REGION"] = grass.region_env(n=n, s=s, e=e, w=w)
res = None
if tgtres == "estimated":
res = estres
elif tgtres == "value":
res = tgtres_value
grass.message(
_("Using given resolution for input band <{out}>: {res}").
format(out=outfile, res=res))
# align to requested resolution
env["GRASS_REGION"] = grass.region_env(res=res, flags="a", env=env)
else:
curr_reg = grass.region()
grass.message(
_("Using current region resolution for input band "
"<{out}>: nsres={ns}, ewres={ew}").format(
out=outfile, ns=curr_reg["nsres"], ew=curr_reg["ewres"]))
# r.proj
grass.message(_("Reprojecting <%s>...") % outfile)
try:
grass.run_command(
"r.proj",
location=TMPLOC,
mapset="PERMANENT",
input=outfile,
method=method,
resolution=res,
memory=memory,
flags=rflags,
quiet=True,
env=env,
)
except CalledModuleError:
grass.fatal(_("Unable to to reproject raster <%s>") % outfile)
if grass.raster_info(outfile)["min"] is None:
grass.fatal(_("The reprojected raster <%s> is empty") % outfile)
if flags["e"]:
return 0
if group:
grass.run_command("i.group", group=output, input=",".join(outfiles))
# TODO: write metadata with r.support
return 0
def function(pa):
pa0 = 'v0_' + pa
os.environ['GRASS_REGION'] = grass.region_env(vect=pa0, res=1000)
#grass. message("omitting previous masks")
grass.run_command('g.remove', rast='MASK')
if pa not in pa_list_done:
opt1 = 'wdpa_id = ' + pa
#print px
#print "Extracting PA:"+pa
#grass.run_command('v.extract', input=source, out=pa0, where = opt1,overwrite=True)
pa2 = pa + 'v2'
pa3 = pa + 'v3'
pa4 = 'paa_' + pa
pa44 = 'pa_' + 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.mask', vector=source, where=opt1)
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]
#grass.run_command('g.remove', rast='MASK')
#print a
minarea = np.sqrt(int(a[1])) #/1000
#print minarea
#grass. message ("segmenting the park")
grass.run_command('i.segment',
group='segm',
output=pa2,
threshold='0.7',
method='region_growing',
similarity='euclidean',
minsize=minarea,
memory='100000',
iterations='20',
overwrite=True)
#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.remove', rast='MASK')
#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 VARCHAR')
grass.run_command('v.db.update', map=pa4, col='wdpaid', value=pa)
#grass. message ("Checking shapefile")
grass.run_command('v.clean',
input=pa4,
out=pa44,
tool='rmarea',
thres=minarea,
overwrite=True)
grass.run_command('v.db.addcolumn', map=pa44, col='wdpa_id VARCHAR')
grass.run_command('v.db.update',
map=pa44,
col='wdpa_id',
qcol='wdpaid || cat')
#grass. message ("Exporting shapefile")
#if pa == 0:
# grass.run_command('v.out.ogr',input=pa44,ola='parks_segmented',dsn='.')
#else:
grass.run_command('v.out.ogr',
flags='a',
input=pa44,
ola='parks_segmented2',
dsn='.')
#grass. message ("Deleting tmp layers")
#grass.run_command('g.mremove',rast='*v3',flags='f')
#grass.run_command('g.mremove',rast='*v2',flags='f')
#grass.run_command('g.mremove',rast='v0_*',flags='f')
#grass.run_command('g.mremove',rast='pa_*',flags='f')
#grass.run_command('g.mremove',vect='v0_*',flags='f')
##grass.run_command('g.mremove',vect='pa_*',flags='f')
#grass.run_command('g.mremove',vect='paa_*',flags='f')
#grass. message ("Done")
print "Done PA:" + pa
wb = open(csvname1, 'a')
var = str(pa)
wb.write(var)
wb.write('\n')
wb.close()
os.environ.pop('GRASS_REGION')
def main():
"""
Superposition of analytical solutions in gFlex for flexural isostasy in
GRASS GIS
"""
options, flags = grass.parser()
# if just interface description is requested, it will not get to this point
# so gflex will not be needed
# GFLEX
# try to import gflex only after we know that
# we will actually do the computation
try:
import gflex
except:
print("")
print("MODULE IMPORT ERROR.")
print(
"In order to run r.flexure or g.flexure, you must download and install"
)
print("gFlex. The most recent development version is available from")
print("https://github.com/awickert/gFlex")
print("Installation instructions are available on the page.")
grass.fatal("Software dependency must be installed.")
##########
# SET-UP #
##########
# This code is for 2D flexural isostasy
flex = gflex.F2D()
# And show that it is coming from GRASS GIS
flex.grass = True
# Method
flex.Method = 'SAS_NG'
# Parameters that are often changed for the solution
######################################################
# x, y, q
flex.x, flex.y = get_points_xy(options['input'])
# xw, yw: gridded output
if len(
grass.parse_command('g.list',
type='vect',
pattern=options['output'])):
if not grass.overwrite():
grass.fatal("Vector map '" + options['output'] +
"' already exists. Use '--o' to overwrite.")
# Just check raster at the same time if it exists
if len(
grass.parse_command('g.list',
type='rast',
pattern=options['raster_output'])):
if not grass.overwrite():
grass.fatal("Raster map '" + options['raster_output'] +
"' already exists. Use '--o' to overwrite.")
grass.run_command('v.mkgrid',
map=options['output'],
type='point',
overwrite=grass.overwrite(),
quiet=True)
grass.run_command('v.db.addcolumn',
map=options['output'],
columns='w double precision',
quiet=True)
flex.xw, flex.yw = get_points_xy(
options['output']) # gridded output coordinates
vect_db = grass.vector_db_select(options['input'])
col_names = np.array(vect_db['columns'])
q_col = (col_names == options['column'])
if np.sum(q_col):
col_values = np.array(list(vect_db['values'].values())).astype(float)
flex.q = col_values[:, q_col].squeeze(
) # Make it 1D for consistency w/ x, y
else:
grass.fatal("provided column name, " + options['column'] +
" does not match\nany column in " + options['q0'] + ".")
# Elastic thickness
flex.Te = float(options['te'])
if options['te_units'] == 'km':
flex.Te *= 1000
elif options['te_units'] == 'm':
pass
else:
grass.fatal(
"Inappropriate te_units. How? Options should be limited by GRASS.")
flex.rho_fill = float(options['rho_fill'])
# Parameters that often stay at their default values
######################################################
flex.g = float(options['g'])
flex.E = float(options['ym']
) # Can't just use "E" because reserved for "east", I think
flex.nu = float(options['nu'])
flex.rho_m = float(options['rho_m'])
# Set verbosity
if grass.verbosity() >= 2:
flex.Verbose = True
if grass.verbosity() >= 3:
flex.Debug = True
elif grass.verbosity() == 0:
flex.Quiet = True
# Check if lat/lon and let user know if verbosity is True
if grass.region_env()[6] == '3':
flex.latlon = True
flex.PlanetaryRadius = float(
grass.parse_command('g.proj', flags='j')['+a'])
if flex.Verbose:
print("Latitude/longitude grid.")
print("Based on r_Earth = 6371 km")
print(
"Computing distances between load points using great circle paths"
)
##########
# SOLVE! #
##########
flex.initialize()
flex.run()
flex.finalize()
# Now to use lower-level GRASS vector commands to work with the database
# table and update its entries
# See for help:
# http://nbviewer.ipython.org/github/zarch/workshop-pygrass/blob/master/02_Vector.ipynb
w = vector.VectorTopo(options['output'])
w.open('rw') # Get ready to read and write
wdb = w.dblinks[0]
wtable = wdb.table()
col = int((np.array(
wtable.columns.names()) == 'w').nonzero()[0]) # update this column
for i in range(1, len(w) + 1):
# ignoring 1st column: assuming it will be category (always true here)
wnewvalues = list(w[i].attrs.values())[1:col] + tuple(
[flex.w[i - 1]]) + list(w[i].attrs.values())[col + 1:]
wtable.update(key=i, values=wnewvalues)
wtable.conn.commit() # Save this
w.close(build=False) # don't build here b/c it is always verbose
grass.run_command('v.build', map=options['output'], quiet=True)
# And raster export
# "w" vector defined by raster resolution, so can do direct v.to.rast
# though if this option isn't selected, the user can do a finer-grained
# interpolation, which shouldn't introduce much error so long as these
# outputs are spaced at << 1 flexural wavelength.
if options['raster_output']:
grass.run_command('v.to.rast',
input=options['output'],
output=options['raster_output'],
use='attr',
attribute_column='w',
type='point',
overwrite=grass.overwrite(),
quiet=True)
# And create a nice colormap!
grass.run_command('r.colors',
map=options['raster_output'],
color='differences',
quiet=True)
def _createOutputMap(self):
"""!Import downloaded data into GRASS, reproject data if needed
using gdalwarp
"""
# reprojection of raster
if self.proj_srs != self.proj_location: # TODO: do it better
grass.message(_("Reprojecting raster..."))
temp_warpmap = self._tempfile()
if int(os.getenv('GRASS_VERBOSE', '2')) <= 2:
nuldev = file(os.devnull, 'w+')
else:
nuldev = None
# RGB rasters - alpha layer is added for cropping edges of projected raster
if self.temp_map_bands_num == 3:
ps = grass.Popen(['gdalwarp',
'-s_srs', '%s' % self.proj_srs,
'-t_srs', '%s' % self.proj_location,
'-r', self.o_method, '-dstalpha',
self.temp_map, temp_warpmap], stdout = nuldev)
# RGBA rasters
else:
ps = grass.Popen(['gdalwarp',
'-s_srs', '%s' % self.proj_srs,
'-t_srs', '%s' % self.proj_location,
'-r', self.o_method,
self.temp_map, temp_warpmap], stdout = nuldev)
ps.wait()
if nuldev:
nuldev.close()
if ps.returncode != 0:
grass.fatal(_('%s failed') % 'gdalwarp')
# raster projection is same as projection of location
else:
temp_warpmap = self.temp_map
grass.message(_("Importing raster map into GRASS..."))
# importing temp_map into GRASS
if grass.run_command('r.in.gdal',
quiet = True,
input = temp_warpmap,
output = self.o_output) != 0:
grass.fatal(_('%s failed') % 'r.in.gdal')
# information for destructor to cleanup temp_layers, created
# with r.in.gdal
self.cleanup_layers = True
# setting region for full extend of imported raster
os.environ['GRASS_REGION'] = grass.region_env(rast = self.o_output + '.red')
# mask created from alpha layer, which describes real extend
# of warped layer (may not be a rectangle), also mask contains
# transparent parts of raster
if grass.find_file( self.o_output + '.alpha', element = 'cell', mapset = '.' )['name']:
# saving current mask (if exists) into temp raster
if grass.find_file('MASK', element = 'cell', mapset = '.' )['name']:
if grass.run_command('g.copy',
quiet = True,
rast = 'MASK,' + self.o_output + self.original_mask_suffix) != 0:
grass.fatal(_('%s failed') % 'g.copy')
# info for destructor
self.cleanup_mask = True
if grass.run_command('r.mask',
quiet = True,
overwrite = True,
maskcats = "0",
flags = 'i',
input = self.o_output + '.alpha') != 0:
grass.fatal(_('%s failed') % 'r.mask')
if grass.run_command('r.composite',
quiet = True,
red = self.o_output + '.red',
green = self.o_output + '.green',
blue = self.o_output + '.blue',
output = self.o_output ) != 0:
grass.fatal(_('%s failed') % 'r.composite')
grass.try_remove(temp_warpmap)
grass.try_remove(self.temp_map)
