def main():
soilloss = options['soilloss']
soilloss3 = soilloss # + '.3'
map = options['map']
parcelnumcol = options['parcelnumcol']
flag_l = flags['l']
flag_h = flags['h']
quiet = True
if gscript.verbosity() > 2:
quiet=False
zones = map.split('@')[0] + '.zones'
v.to_rast( input=map, use='attr', attrcolumn=parcelnumcol,
output=zones, quiet=quiet)
def printStats(table, tablefmt='simple'):
try:
from tabulate import tabulate
except:
gscript.warning('Install tabulate for pretty printing tabular output ($ pip install tabulate). Using pprint instead...')
from pprint import pprint
pprint(statout)
print tabulate(table,headers='firstrow',tablefmt=tablefmt)
if not flag_h:
runivar = r.univar(map=soilloss, zones=zones, flags='t', stdout=gscript.PIPE)
rstats = runivar.outputs.stdout.strip().split('\n')
#show all available values columns
#rstats[0].split('|')
rstatout = []
for line in range(len(rstats)):
lineout = []
for i in (0,7,9,4,5):
lineout += (rstats[line].split('|')[i],)
rstatout.append(lineout)
if flag_l: printStats(rstatout, tablefmt='latex')
else: printStats(rstatout)
if flag_h:
r.report(map=(zones,soilloss3),units='p',flags='')
def main():
soillossbare = options['soillossbare']
soillossgrow = options['soillossgrow']
cfactor = options['cfactor']
pfactor = options['pfactor']
map = options['map']
factorcols = options['factorcols'].split(',')
quiet = True
if gscript.verbosity() > 2:
quiet=False
if not (cfactor or pfactor):
if not map:
gscript.fatal('Please give either factor raster map(s) or vector map with factor(s)')
elif not factorcols:
gscript.fatal("Please give 'factorcols' (attribute columns with factor(s)) for <%s>" %map)
factors = ()
for factorcol in factorcols:
output = map.split('@')[0] + '.' + factorcol
gscript.message('Rasterize <%s> with attribute <%s>' %(map, factorcol)
+ '\n to raster map <%s> ...' %(output) )
v.to_rast(input=map, use='attr', attrcolumn=factorcol,
output=output, quiet=quiet)
factors += (output,)
else: factors = (cfactor, pfactor)
gscript.message('Multiply factors <%s> with <%s> ...' %(factors, soillossbare) )
formula = soillossgrow + '=' + soillossbare
for factor in factors:
formula += '*' + factor
r.mapcalc(formula)
## apply color rules
r.colors(map = soillossgrow,
rules = '-', stdin = colorrules['soillossgrow'],
quiet = quiet)
def main():
raster = options['raster']
maskcats = options['maskcats']
vector = options['vector']
layer = options['layer']
cats = options['cats']
where = options['where']
remove = flags['r']
invert = flags['i']
if not remove and not raster and not vector:
grass.fatal(_("Either parameter <raster> ot parameter <vector> is required"))
mapset = grass.gisenv()['MAPSET']
exists = bool(grass.find_file('MASK', element='cell', mapset=mapset)['file'])
if remove:
# -> remove
if exists:
if sys.platform == 'win32':
grass.run_command('g.remove', flags='if', quiet=True,
type='raster', name='MASK')
else:
grass.run_command('g.remove', flags='f', quiet=True,
type='raster', name='MASK')
grass.message(_("Raster MASK removed"))
else:
grass.fatal(_("No existing MASK to remove"))
else:
# -> create
if exists:
if not grass.overwrite():
grass.fatal(_("MASK already found in current mapset. Delete first or overwrite."))
else:
grass.warning(_("MASK already exists and will be overwritten"))
grass.run_command('g.remove', flags='f', quiet=True,
type='raster', name='MASK')
if raster:
# check if input raster exists
if not grass.find_file(raster)['file']:
grass.fatal(_("Raster map <%s> not found") % raster)
if maskcats != '*' and not remove:
if grass.raster_info(raster)['datatype'] != "CELL":
grass.fatal(_("The raster map <%s> must be integer (CELL type) "
" in order to use the 'maskcats' parameter") % raster)
p = grass.feed_command(
'r.reclass',
input=raster,
output='MASK',
overwrite=True,
rules='-')
p.stdin.write("%s = 1" % maskcats)
p.stdin.close()
p.wait()
elif vector:
vector_name = grass.find_file(vector, 'vector')['fullname']
if not vector_name:
grass.fatal(_("Vector map <%s> not found") % vector)
# parser bug?
if len(cats) == 0:
cats = None
if len(where) == 0:
where = None
if grass.vector_info_topo(vector_name)['areas'] < 1:
grass.warning(_("No area found in vector map <%s>. "
"Creating a convex hull for MASK.") % vector_name)
global tmp_hull
tmp_hull = "tmp_hull_%d" % os.getpid()
to_rast_input = tmp_hull
# force 'flat' convex hull for 3D vector maps
try:
grass.run_command('v.hull', flags='f', quiet=True,
input=vector_name, output=tmp_hull,
layer=layer, cats=cats, where=where)
except CalledModuleError:
grass.fatal(
_("Unable to create a convex hull for vector map <%s>") %
vector_name)
else:
to_rast_input = vector_name
env = os.environ.copy()
if grass.verbosity() > 1:
env['GRASS_VERBOSE'] = '1'
grass.run_command('v.to.rast', input=to_rast_input, layer=layer,
output='MASK', use='val', val='1',
type='area', cats=cats, where=where, env=env)
if invert:
global tmp
tmp = "r_mask_%d" % os.getpid()
grass.run_command('g.rename', raster=('MASK', tmp), quiet=True)
grass.message(_("Creating inverted raster MASK..."))
grass.mapcalc("MASK = if(isnull($tmp), 1, null())", tmp=tmp)
grass.verbose(_("Inverted raster MASK created"))
else:
grass.verbose(_("Raster MASK created"))
grass.message(_("All subsequent raster operations will be limited to "
"the MASK area. Removing or renaming raster map named "
"'MASK' will restore raster operations to normal."))
def main():
# Get the options
input = options["input"]
output = options["output"]
method = options["method"]
min_cat = None
max_cat = None
point = None
overwrite = grass.overwrite()
quiet = True
if grass.verbosity() > 2:
quiet = False
in_info = grass.vector_info(input)
# check for wild mixture of vector types
if in_info['points'] > 0 and in_info['boundaries'] > 0:
grass.fatal(_("The input vector map contains both polygons and points,"
" cannot handle mixed types"))
pid = os.getpid()
# process points via triangulation, then exit
if in_info['points'] > 0:
point = True
layer = 1 # hardcoded for now
out_temp = '{inp}_point_tmp_{pid}'.format(inp=input, pid=pid)
if method == 'delaunay':
grass.message(_("Processing point data (%d points found)...") % in_info['points'])
grass.run_command('v.delaunay', input=input, layer=layer,
output=out_temp, quiet=quiet)
grass.run_command('v.db.addtable', map=out_temp, quiet=True)
input = out_temp
in_info = grass.vector_info(input)
# process areas
if in_info['areas'] == 0 and in_info['boundaries'] == 0:
grass.fatal(_("The input vector map does not contain polygons"))
out_type = '{inp}_type_{pid}'.format(inp=input, pid=pid)
input_tmp = '{inp}_tmp_{pid}'.format(inp=input, pid=pid)
remove_names = "%s,%s" % (out_type, input_tmp)
grass.message(_("Processing area data (%d areas found)...") % in_info['areas'])
if 0 != grass.run_command('v.category', layer="2", type='boundary',
option='add', input=input, out=input_tmp,
quiet=quiet):
grass.run_command('g.remove', flags='f', type='vect',
pattern=input_tmp, quiet=quiet)
grass.fatal(_("Error creating layer 2"))
if 0 != grass.run_command('v.db.addtable', map=input_tmp, layer="2",
columns="left integer,right integer",
quiet=quiet):
grass.run_command('g.remove', flags='f', type='vect',
pattern=input_tmp, quiet=quiet)
grass.fatal(_("Error creating new table for layer 2"))
if 0 != grass.run_command('v.to.db', map=input_tmp, option="sides",
columns="left,right", layer="2", quiet=quiet):
grass.run_command('g.remove', flags='f', type='vect',
pattern=input_tmp, quiet=quiet)
grass.fatal(_("Error populating new table for layer 2"))
if 0 != grass.run_command('v.type', input=input_tmp, output=out_type,
from_type='boundary', to_type='line',
quiet=quiet, layer="2"):
grass.run_command('g.remove', flags='f', type='vect',
pattern=remove_names, quiet=quiet)
grass.fatal(_("Error converting polygon to line"))
report = grass.read_command('v.category', flags='g', input=out_type,
option='report', quiet=quiet).split('\n')
for r in report:
if r.find('centroid') != -1:
min_cat = report[0].split()[-2]
max_cat = report[0].split()[-1]
break
if min_cat and max_cat:
if 0 != grass.run_command('v.edit', map=out_type, tool='delete',
type='centroid', layer=2, quiet=quiet,
cats='{mi}-{ma}'.format(mi=min_cat, ma=max_cat)):
grass.run_command('g.remove', flags='f', type='vect',
pattern=remove_names, quiet=quiet)
grass.fatal(_("Error removing centroids"))
try:
if 0 != grass.run_command('v.db.droptable', map=out_type, layer=1,
flags='f', quiet=True):
grass.run_command('g.remove', flags='f', type='vect',
pattern=remove_names, quiet=quiet)
grass.fatal(_("Error removing table from layer 1"))
except:
grass.warning(_("No table for layer %d" % 1))
if 0 != grass.run_command('v.category', input=out_type, option='transfer',
output=output, layer="2,1", quiet=quiet,
overwrite=overwrite):
grass.run_command('g.remove', flags='f', type='vect',
pattern=remove_names, quiet=quiet)
grass.fatal(_("Error adding categories"))
grass.run_command('g.remove', flags='f', type='vect',
pattern=remove_names, quiet=quiet)
if point:
grass.run_command('g.remove', flags='f', type='vect',
pattern=out_temp, quiet=quiet)
def main():
# Get the options
input = options["input"]
output = options["output"]
strds = options["strds"]
where = options["where"]
tempwhere = options["t_where"]
if output and flags['u']:
grass.fatal(_("Cannot combine 'output' option and 'u' flag"))
elif not output and not flags['u']:
grass.fatal(_("'output' option or 'u' flag must be given"))
elif not output and flags['u']:
grass.warning(_("Attribute table of vector {name} will be updated...").format(name=input))
if where == "" or where == " " or where == "\n":
where = None
overwrite = grass.overwrite()
quiet = True
if grass.verbosity() > 2:
quiet = False
# Check the number of sample strds and the number of columns
strds_names = strds.split(",")
# Make sure the temporal database exists
tgis.init()
# We need a database interface
dbif = tgis.SQLDatabaseInterfaceConnection()
dbif.connect()
samples = []
first_strds = tgis.open_old_stds(strds_names[0], "strds", dbif)
# Single space time raster dataset
if len(strds_names) == 1:
rows = first_strds.get_registered_maps("name,mapset,start_time,end_time",
tempwhere, "start_time",
dbif)
if not rows:
dbif.close()
grass.fatal(_("Space time raster dataset <%s> is empty") %
first_strds.get_id())
for row in rows:
start = row["start_time"]
end = row["end_time"]
raster_maps = [row["name"] + "@" + row["mapset"], ]
s = Sample(start, end, raster_maps, first_strds.get_name())
samples.append(s)
else:
# Multiple space time raster datasets
for name in strds_names[1:]:
dataset = tgis.open_old_stds(name, "strds", dbif)
if dataset.get_temporal_type() != first_strds.get_temporal_type():
grass.fatal(_("Temporal type of space time raster "
"datasets must be equal\n<%(a)s> of type "
"%(type_a)s do not match <%(b)s> of type "
"%(type_b)s" % {"a": first_strds.get_id(),
"type_a": first_strds.get_temporal_type(),
"b": dataset.get_id(),
"type_b": dataset.get_temporal_type()}))
mapmatrizes = tgis.sample_stds_by_stds_topology("strds", "strds",
strds_names,
strds_names[0],
False, None,
"equal", False,
False)
for i in xrange(len(mapmatrizes[0])):
isvalid = True
mapname_list = []
for mapmatrix in mapmatrizes:
entry = mapmatrix[i]
if entry["samples"]:
sample = entry["samples"][0]
name = sample.get_id()
if name is None:
isvalid = False
break
else:
mapname_list.append(name)
if isvalid:
entry = mapmatrizes[0][i]
map = entry["granule"]
start, end = map.get_temporal_extent_as_tuple()
s = Sample(start, end, mapname_list, name)
samples.append(s)
# Get the layer and database connections of the input vector
if output:
gcopy(input, output, 'vector')
else:
output = input
msgr = Messenger()
perc_curr = 0
perc_tot = len(samples)
pymap = Vector(output)
try:
pymap.open('r')
except:
dbif.close()
grass.fatal(_("It is not possible to open the new map %s" % output))
if len(pymap.dblinks) == 0:
try:
grass.run_command("v.db.addtable", map=output)
except CalledModuleError:
dbif.close()
grass.fatal(_("Impossible add table to vector %s" % output))
pymap.close()
for sample in samples:
raster_names = sample.raster_names
# Call v.what.rast for each raster map
for name in raster_names:
coltype = "DOUBLE PRECISION"
# Get raster map type
raster_map = tgis.RasterDataset(name)
raster_map.load()
if raster_map.metadata.get_datatype() == "CELL":
coltype = "INT"
day = sample.printDay()
column_name = "%s_%s" % (sample.strds_name, day)
column_string = "%s %s" % (column_name, coltype)
column_string.replace('.', '_')
try:
grass.run_command("v.db.addcolumn", map=output,
column=column_string,
overwrite=overwrite)
except CalledModuleError:
dbif.close()
grass.fatal(_("Unable to add column %s to vector map "
"<%s> ") % (column_string, output))
try:
grass.run_command("v.what.rast", map=output, raster=name,
column=column_name, where=where,
quiet=quiet)
except CalledModuleError:
dbif.close()
grass.fatal(_("Unable to run v.what.rast for vector map"
" <%s> and raster map <%s>") %
(output, str(raster_names)))
msgr.percent(perc_curr, perc_tot, 1)
perc_curr += 1
dbif.close()
def main():
raster = options['raster']
maskcats = options['maskcats']
vector = options['vector']
layer = options['layer']
cats = options['cats']
where = options['where']
remove = flags['r']
invert = flags['i']
if not remove and not raster and not vector:
grass.fatal(
_("Either parameter <raster> ot parameter <vector> is required"))
mapset = grass.gisenv()['MAPSET']
exists = bool(
grass.find_file('MASK', element='cell', mapset=mapset)['file'])
if remove:
# -> remove
if exists:
grass.run_command('g.remove',
flags='f',
quiet=True,
type='raster',
name='MASK')
grass.message(_("Raster MASK removed"))
else:
grass.fatal(_("No existing MASK to remove"))
else:
# -> create
if exists:
if not grass.overwrite():
grass.fatal(
_("MASK already found in current mapset. Delete first or overwrite."
))
else:
grass.warning(_("MASK already exists and will be overwritten"))
grass.run_command('g.remove',
flags='f',
quiet=True,
type='raster',
name='MASK')
if raster:
# check if input raster exists
if not grass.find_file(raster)['file']:
grass.fatal(_("Raster map <%s> not found") % raster)
if maskcats != '*' and not remove:
if grass.raster_info(raster)['datatype'] != "CELL":
grass.fatal(
_("The raster map <%s> must be integer (CELL type) "
" in order to use the 'maskcats' parameter") %
raster)
p = grass.feed_command('r.reclass',
input=raster,
output='MASK',
overwrite=True,
rules='-')
p.stdin.write("%s = 1" % maskcats)
p.stdin.close()
p.wait()
elif vector:
vector_name = grass.find_file(vector, 'vector')['fullname']
if not vector_name:
grass.fatal(_("Vector map <%s> not found") % vector)
# parser bug?
if len(cats) == 0:
cats = None
if len(where) == 0:
where = None
if grass.vector_info_topo(vector_name)['areas'] < 1:
grass.warning(
_("No area found in vector map <%s>. "
"Creating a convex hull for MASK.") % vector_name)
global tmp_hull
tmp_hull = "tmp_hull_%d" % os.getpid()
to_rast_input = tmp_hull
# force 'flat' convex hull for 3D vector maps
try:
grass.run_command('v.hull',
flags='f',
quiet=True,
input=vector_name,
output=tmp_hull,
layer=layer,
cats=cats,
where=where)
except CalledModuleError:
grass.fatal(
_("Unable to create a convex hull for vector map <%s>")
% vector_name)
else:
to_rast_input = vector_name
env = os.environ.copy()
if grass.verbosity() > 1:
env['GRASS_VERBOSE'] = '1'
grass.run_command('v.to.rast',
input=to_rast_input,
layer=layer,
output='MASK',
use='val',
val='1',
type='area',
cats=cats,
where=where,
env=env)
if invert:
global tmp
tmp = "r_mask_%d" % os.getpid()
grass.run_command('g.rename', raster=('MASK', tmp), quiet=True)
grass.message(_("Creating inverted raster MASK..."))
grass.mapcalc("MASK = if(isnull($tmp), 1, null())", tmp=tmp)
grass.verbose(_("Inverted raster MASK created"))
else:
grass.verbose(_("Raster MASK created"))
grass.message(
_("All subsequent raster operations will be limited to "
"the MASK area. Removing or renaming raster map named "
"'MASK' will restore raster operations to normal."))
def main():
raster = options["raster"]
maskcats = options["maskcats"]
vector = options["vector"]
layer = options["layer"]
cats = options["cats"]
where = options["where"]
remove = flags["r"]
invert = flags["i"]
if not remove and not raster and not vector:
grass.fatal(_("Either parameter <raster> ot parameter <vector> is required"))
mapset = grass.gisenv()["MAPSET"]
exists = bool(grass.find_file("MASK", element="cell", mapset=mapset)["file"])
if remove:
# -> remove
if exists:
grass.run_command("g.remove", flags="f", quiet=True, type="rast", pattern="MASK")
grass.message(_("Raster MASK removed"))
else:
grass.fatal(_("No existing MASK to remove"))
else:
# -> create
if exists:
if not grass.overwrite():
grass.fatal(_("MASK already found in current mapset. Delete first or overwrite."))
else:
grass.warning(_("MASK already exists and will be overwritten"))
grass.run_command("g.remove", flags="f", quiet=True, type="rast", pattern="MASK")
if raster:
# check if input raster exists
if not grass.find_file(raster)["file"]:
grass.fatal(_("Raster map <%s> not found") % raster)
if maskcats != "*" and not remove:
if grass.raster_info(raster)["datatype"] != "CELL":
grass.fatal(
_(
"The raster map <%s> must be integer (CELL type) "
" in order to use the 'maskcats' parameter"
)
% raster
)
p = grass.feed_command("r.reclass", input=raster, output="MASK", overwrite=True, rules="-")
p.stdin.write("%s = 1" % maskcats)
p.stdin.close()
p.wait()
elif vector:
vector_name = grass.find_file(vector, "vector")["fullname"]
if not vector_name:
grass.fatal(_("Vector map <%s> not found") % vector)
# parser bug?
if len(cats) == 0:
cats = None
if len(where) == 0:
where = None
if grass.vector_info_topo(vector_name)["areas"] < 1:
grass.warning(_("No area found in vector map <%s>. " "Creating a convex hull for MASK.") % vector_name)
global tmp_hull
tmp_hull = "tmp_hull_%d" % os.getpid()
to_rast_input = tmp_hull
# force 'flat' convex hull for 3D vector maps
if 0 != grass.run_command(
"v.hull",
flags="f",
quiet=True,
input=vector_name,
output=tmp_hull,
layer=layer,
cats=cats,
where=where,
):
grass.fatal(_("Unable to create a convex hull for vector map <%s>") % vector_name)
else:
to_rast_input = vector_name
env = os.environ.copy()
if grass.verbosity() > 1:
env["GRASS_VERBOSE"] = "1"
grass.run_command(
"v.to.rast",
input=to_rast_input,
layer=layer,
output="MASK",
use="val",
val="1",
type="area",
cats=cats,
where=where,
env=env,
)
if invert:
global tmp
tmp = "r_mask_%d" % os.getpid()
grass.run_command("g.rename", rast=("MASK", tmp), quiet=True)
grass.message(_("Creating inverted raster MASK..."))
grass.mapcalc("MASK = if(isnull($tmp), 1, null())", tmp=tmp)
grass.verbose(_("Inverted raster MASK created"))
else:
grass.verbose(_("Raster MASK created"))
grass.message(
_(
"All subsequent raster operations will be limited to "
"the MASK area. Removing or renaming raster map named "
"'MASK' will restore raster operations to normal."
)
)
def main():
# lazy imports
import grass.temporal as tgis
# Get the options
type = options["type"]
temporal_type = options["temporaltype"]
columns = options["columns"]
order = options["order"]
where = options["where"]
separator = gscript.separator(options["separator"])
outpath = options["output"]
colhead = flags['c']
# Make sure the temporal database exists
tgis.init()
sp = tgis.dataset_factory(type, None)
dbif = tgis.SQLDatabaseInterfaceConnection()
dbif.connect()
first = True
if gscript.verbosity() > 0 and not outpath:
sys.stderr.write("----------------------------------------------\n")
if outpath:
outfile = open(outpath, 'w')
for ttype in temporal_type.split(","):
if ttype == "absolute":
time = "absolute time"
else:
time = "relative time"
stds_list = tgis.get_dataset_list(type, ttype, columns, where, order, dbif=dbif)
# Use the correct order of the mapsets, hence first the current mapset, then
# alphabetic ordering
mapsets = tgis.get_tgis_c_library_interface().available_mapsets()
# Print for each mapset separately
for key in mapsets:
if key in stds_list.keys():
rows = stds_list[key]
if rows:
if gscript.verbosity() > 0 and not outpath:
if issubclass(sp.__class__, tgis.AbstractMapDataset):
sys.stderr.write(_("Time stamped %s maps with %s available in mapset <%s>:\n")%
(sp.get_type(), time, key))
else:
sys.stderr.write(_("Space time %s datasets with %s available in mapset <%s>:\n")%
(sp.get_new_map_instance(None).get_type(), time, key))
# Print the column names if requested
if colhead and first:
output = ""
count = 0
for key in rows[0].keys():
if count > 0:
output += separator + str(key)
else:
output += str(key)
count += 1
if outpath:
outfile.write("{st}\n".format(st=output))
else:
print(output)
first = False
for row in rows:
output = ""
count = 0
for col in row:
if count > 0:
output += separator + str(col)
else:
output += str(col)
count += 1
if outpath:
outfile.write("{st}\n".format(st=output))
else:
print(output)
if outpath:
outfile.close()
dbif.close()
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 main():
# parameters
infile = options["input"]
raster_reference = options["raster_reference"]
raster_file = options["raster_file"]
outfiles = options["output"]
resolution = options["resolution"]
methods = options["method"]
zrange = options["zrange"]
zscale = options["zscale"]
output_type = options["type"]
percent = options["percent"]
pth = options["pth"]
trim = options["trim"]
footprint = options["footprint"]
# flags
scan = flags["s"]
shell_script_style = flags["g"]
if len(outfiles.split(",")) != len(methods.split(",")):
grass.fatal(
_("Number of outputs <%s> does not match number of methods <%s>" %
(outfiles, methods)))
# overwrite auf true setzen
os.environ["GRASS_OVERWRITE"] = "1"
# to hide non-error messages from subprocesses
if grass.verbosity() <= 2:
outdev = open(os.devnull, "w")
else:
outdev = sys.stdout
# use temporary region
grass.use_temp_region()
n, s, w, e, t, b = scan_extent(infile)
# scan -s or shell_script_style -g:
if scan:
if not shell_script_style:
grass.message(
_("north: %s\nsouth: %s\nwest: %s\neast: %s\ntop: %s\nbottom: %s"
) % (n, s, w, e, t, b))
else:
# shell script style: print to stdout
print("n=%s s=%s w=%s e=%s t=%s b=%s" % (n, s, w, e, t, b))
elif footprint:
footprint_to_vectormap(infile, footprint)
else:
# get region with pdal
# footprint_to_vectormap(infile, 'tiles')
if raster_file:
raster_reference = "img" + str(os.getpid())
grass.run_command("r.external",
input=raster_file,
flags="o",
output=raster_reference)
result = grass.find_file(name=raster_reference, element="raster")
if result[u"fullname"] == u"":
raster_reference = raster_reference + ".1"
# option 1: set region to extent of tiles while precisely aligning pixel
# geometry to raster_reference (including both raster_reference and raster_file)
if raster_reference:
grass.run_command("g.region",
n=n,
s=s,
e=e,
w=w,
flags="g",
align=raster_reference)
else:
# option 2: change raster resolution to final resolution while best
# effort aligning to pixel geometry
grass.run_command("g.region",
n=n,
s=s,
e=e,
w=w,
flags="ap",
res=resolution)
# generate PDAL pipeline
# . pdal pipline laz2json (STDOUT) | r.in.xyz
bn = os.path.basename(infile)
infile_format = bn.split(".")[-1]
# format_reader from https://pdal.io/stages/readers.html
format_reader = ""
if infile_format.lower() == "laz" or infile_format.lower() == "las":
format_reader = "readers.las"
# pts: not tested
elif infile_format.lower() == "pts":
format_reader = "readers.pts"
else:
grass.run_command("g.remove",
flags="f",
type="vector",
name="tiles",
quiet=True)
grass.fatal(_("Format .%s is not supported.." % infile_format))
grass.message(_("Converting input file <%s>...") % infile)
tmp_file_json = "tmp_file_json_" + str(os.getpid())
data = {}
data["pipeline"] = []
data["pipeline"].append({"type": format_reader, "filename": infile})
data["pipeline"].append({
"type": "writers.text",
"format": "csv",
"order": "X,Y,Z",
"keep_unspecified": "false",
"filename": "STDOUT",
"quote_header": "false",
})
with open(tmp_file_json, "w") as f:
json.dump(data, f)
tmp_xyz = grass.tempfile()
if tmp_xyz is None:
grass.fatal("Unable to create temporary files")
command_pdal1 = options["pdal_cmd"].split(" ")
if options["pdal_cmd"] != "pdal":
v_index = None
cmd_entries = options["pdal_cmd"].split(" ")
for cmd_entry, num in zip(cmd_entries, range(len(cmd_entries))):
if cmd_entry == "-v":
v_index = num
break
mnt_vol = cmd_entries[v_index + 1].split(":")[1]
tmp_file_json2 = os.path.join(mnt_vol, tmp_file_json)
else:
tmp_file_json2 = tmp_file_json
command_pdal1.extend(["pipeline", "--input", tmp_file_json2])
fh = open(tmp_xyz, "wb")
if grass.call(command_pdal1, stdout=fh) != 0:
fh.close()
# check to see if pdal pipeline executed properly
print(command_pdal1)
grass.fatal(_("pdal pipeline is broken..."))
else:
fh.close()
for i in range(len(methods.split(","))):
method = methods.split(",")[i]
outfile = outfiles.split(",")[i]
grass.message(_("Generating output raster map <%s>...") % outfile)
command_pdal2 = [
"r.in.xyz",
"input=" + tmp_xyz,
"output=" + outfile,
"skip=1",
"separator=comma",
"method=" + method,
]
if zrange:
command_pdal2.append("zrange=" + zrange)
if zscale:
command_pdal2.append("zscale=" + zscale)
if output_type:
command_pdal2.append("type=" + output_type)
if percent:
command_pdal2.append("percent=" + percent)
if pth:
command_pdal2.append("pth=" + pth)
if trim:
command_pdal2.append("trim=" + trim)
if grass.call(command_pdal2, stdout=outdev) != 0:
# check to see if r.in.xyz executed properly
os.remove(tmp_xyz)
grass.fatal(_("r.in.xyz is broken..."))
# metadata
empty_history = grass.tempfile()
if empty_history is None:
grass.fatal("Unable to create temporary files")
f = open(empty_history, "w")
f.close()
grass.run_command(
"r.support",
map=outfile,
source1=infile,
description="generated by r.in.pdal",
loadhistory=empty_history,
)
grass.run_command("r.support",
map=outfile,
history=os.environ["CMDLINE"])
os.remove(empty_history)
# Cleanup
grass.message(_("Cleaning up..."))
grass.run_command("g.remove",
flags="f",
type="vector",
name="tiles",
quiet=True)
if raster_file:
grass.run_command(
"g.remove",
flags="f",
type="raster",
pattern=raster_reference[:-1] + "*",
quiet=True,
)
os.remove(tmp_file_json)
os.remove(tmp_xyz)
grass.del_temp_region()
def main():
# Get the options
input = options["input"]
input_name = input.split("@")[0]
output = options["output"]
method = options["method"]
min_cat = None
max_cat = None
point = None
overwrite = grass.overwrite()
quiet = True
if grass.verbosity() > 2:
quiet = False
in_info = grass.vector_info(input)
# check for wild mixture of vector types
if in_info["points"] > 0 and in_info["boundaries"] > 0:
grass.fatal(_("The input vector map contains both polygons and points," " cannot handle mixed types"))
pid = os.getpid()
# process points via triangulation, then exit
if in_info["points"] > 0:
point = True
layer = 1 # hardcoded for now
out_temp = "{inp}_point_tmp_{pid}".format(inp=input_name, pid=pid)
if method == "delaunay":
grass.message(_("Processing point data (%d points found)...") % in_info["points"])
grass.run_command("v.delaunay", input=input, layer=layer, output=out_temp, quiet=quiet)
grass.run_command("v.db.addtable", map=out_temp, quiet=True)
input = out_temp
in_info = grass.vector_info(input)
# process areas
if in_info["areas"] == 0 and in_info["boundaries"] == 0:
grass.fatal(_("The input vector map does not contain polygons"))
out_type = "{inp}_type_{pid}".format(inp=input_name, pid=pid)
input_tmp = "{inp}_tmp_{pid}".format(inp=input_name, pid=pid)
remove_names = "%s,%s" % (out_type, input_tmp)
grass.message(_("Processing area data (%d areas found)...") % in_info["areas"])
try:
grass.run_command(
"v.category", layer="2", type="boundary", option="add", input=input, out=input_tmp, quiet=quiet
)
except CalledModuleError:
grass.run_command("g.remove", flags="f", type="vector", name=input_tmp, quiet=quiet)
grass.fatal(_("Error creating layer 2"))
try:
grass.run_command("v.db.addtable", map=input_tmp, layer="2", columns="left integer,right integer", quiet=quiet)
except CalledModuleError:
grass.run_command("g.remove", flags="f", type="vector", name=input_tmp, quiet=quiet)
grass.fatal(_("Error creating new table for layer 2"))
try:
grass.run_command("v.to.db", map=input_tmp, option="sides", columns="left,right", layer="2", quiet=quiet)
except CalledModuleError:
grass.run_command("g.remove", flags="f", type="vector", name=input_tmp, quiet=quiet)
grass.fatal(_("Error populating new table for layer 2"))
try:
grass.run_command(
"v.type", input=input_tmp, output=out_type, from_type="boundary", to_type="line", quiet=quiet, layer="2"
)
except CalledModuleError:
grass.run_command("g.remove", flags="f", type="vector", name=remove_names, quiet=quiet)
grass.fatal(_("Error converting polygon to line"))
report = grass.read_command("v.category", flags="g", input=out_type, option="report", quiet=quiet).split("\n")
for r in report:
if r.find("centroid") != -1:
min_cat = report[0].split()[-2]
max_cat = report[0].split()[-1]
break
if min_cat and max_cat:
try:
grass.run_command(
"v.edit",
map=out_type,
tool="delete",
type="centroid",
layer=2,
quiet=quiet,
cats="{mi}-{ma}".format(mi=min_cat, ma=max_cat),
)
except CalledModuleError:
grass.run_command("g.remove", flags="f", type="vector", name=remove_names, quiet=quiet)
grass.fatal(_("Error removing centroids"))
try:
try:
# TODO: fix magic numbers for layer here and there
grass.run_command("v.db.droptable", map=out_type, layer=1, flags="f", quiet=True)
except CalledModuleError:
grass.run_command("g.remove", flags="f", type="vector", name=remove_names, quiet=quiet)
grass.fatal(_("Error removing table from layer 1"))
# TODO: when this except is happaning, it seems that never, so it seems wrong
except:
grass.warning(_("No table for layer %d" % 1))
try:
grass.run_command(
"v.category",
input=out_type,
option="transfer",
output=output,
layer="2,1",
quiet=quiet,
overwrite=overwrite,
)
except CalledModuleError:
grass.run_command("g.remove", flags="f", type="vector", name=remove_names, quiet=quiet)
grass.fatal(_("Error adding categories"))
grass.run_command("g.remove", flags="f", type="vector", name=remove_names, quiet=quiet)
if point:
grass.run_command("g.remove", flags="f", type="vector", name=out_temp, quiet=quiet)
def main():
"""Do the main work"""
# set numpy printing options
np.set_printoptions(formatter={"float": lambda x: "{0:0.2f}".format(x)})
# ==========================================================================
# Input data
# ==========================================================================
# Required
r_output = options["output"]
r_dsm = options["input"]
dsm_type = grass.parse_command("r.info", map=r_dsm, flags="g")["datatype"]
# Test if DSM exist
gfile_dsm = grass.find_file(name=r_dsm, element="cell")
if not gfile_dsm["file"]:
grass.fatal("Raster map <{}> not found".format(r_dsm))
# Exposure settings
v_source = options["sampling_points"]
r_source = options["source"]
source_cat = options["sourcecat"]
r_weights = options["weights"]
# test if source vector map exist and contains points
if v_source:
gfile_vsource = grass.find_file(name=v_source, element="vector")
if not gfile_vsource["file"]:
grass.fatal("Vector map <{}> not found".format(v_source))
if not grass.vector.vector_info_topo(v_source, layer=1)["points"] > 0:
grass.fatal("Vector map <{}> does not contain any points.".format(
v_source))
if r_source:
gfile_rsource = grass.find_file(name=r_source, element="cell")
if not gfile_rsource["file"]:
grass.fatal("Raster map <{}> not found".format(r_source))
# if source_cat is set, check that r_source is CELL
source_datatype = grass.parse_command("r.info",
map=r_source,
flags="g")["datatype"]
if source_cat != "*" and source_datatype != "CELL":
grass.fatal(
"The raster map <%s> must be integer (CELL type) in order to \
use the 'sourcecat' parameter" % r_source)
if r_weights:
gfile_weights = grass.find_file(name=r_weights, element="cell")
if not gfile_weights["file"]:
grass.fatal("Raster map <{}> not found".format(r_weights))
# Viewshed settings
range_inp = float(options["range"])
v_elevation = float(options["observer_elevation"])
b_1 = float(options["b1_distance"])
pfunction = options["function"]
refr_coeff = float(options["refraction_coeff"])
flagstring = ""
if flags["r"]:
flagstring += "r"
if flags["c"]:
flagstring += "c"
# test values
if v_elevation < 0.0:
grass.fatal("Observer elevation must be larger than or equal to 0.0.")
if range_inp <= 0.0 and range_inp != -1:
grass.fatal("Exposure range must be larger than 0.0.")
if pfunction == "Fuzzy_viewshed" and range_inp == -1:
grass.fatal("Exposure range cannot be \
infinity for fuzzy viewshed approch.")
if pfunction == "Fuzzy_viewshed" and b_1 > range_inp:
grass.fatal("Exposure range must be larger than radius around \
the viewpoint where clarity is perfect.")
# Sampling settings
source_sample_density = float(options["sample_density"])
seed = options["seed"]
if not seed: # if seed is not set, set it to process number
seed = os.getpid()
# Optional
cores = int(options["nprocs"])
memory = int(options["memory"])
# ==========================================================================
# Region settings
# ==========================================================================
# check that location is not in lat/long
if grass.locn_is_latlong():
grass.fatal("The analysis is not available for lat/long coordinates.")
# get comp. region parameters
reg = Region()
# check that NSRES equals EWRES
if abs(reg.ewres - reg.nsres) > 1e-6:
grass.fatal("Variable north-south and east-west 2D grid resolution \
is not supported")
# adjust exposure range as a multiplicate of region resolution
# if infinite, set exposure range to the max of region size
if range_inp != -1:
multiplicate = math.floor(range_inp / reg.nsres)
exp_range = multiplicate * reg.nsres
else:
range_inf = max(reg.north - reg.south, reg.east - reg.west)
multiplicate = math.floor(range_inf / reg.nsres)
exp_range = multiplicate * reg.nsres
if RasterRow("MASK", Mapset().name).exist():
grass.warning("Current MASK is temporarily renamed.")
unset_mask()
# ==========================================================================
# Random sample exposure source with target points T
# ==========================================================================
if v_source:
# go for using input vector map as sampling points
v_source_sample = v_source
grass.verbose("Using sampling points from input vector map")
else:
# go for sampling
# min. distance between samples set to half of region resolution
# (issue in r.random.cells)
sample_distance = reg.nsres / 2
v_source_sample = sample_raster_with_points(
r_source,
source_cat,
source_sample_density,
sample_distance,
"{}_rand_pts_vect".format(TEMPNAME),
seed,
)
# ==========================================================================
# Get coordinates and attributes of target points T
# ==========================================================================
# Prepare a list of maps to extract attributes from
# DSM values
attr_map_list = [r_dsm]
if pfunction in ["Solid_angle", "Visual_magnitude"]:
grass.verbose("Precomputing parameter maps...")
# Precompute values A, B, C, D for solid angle function
# using moving window [row, col]
if pfunction == "Solid_angle":
r_a_z = "{}_A_z".format(TEMPNAME)
r_b_z = "{}_B_z".format(TEMPNAME)
r_c_z = "{}_C_z".format(TEMPNAME)
r_d_z = "{}_D_z".format(TEMPNAME)
expr = ";".join([
"$outmap_A = ($inmap[0, 0] + \
$inmap[0, -1] + \
$inmap[1, -1] + \
$inmap[1, 0]) / 4",
"$outmap_B = ($inmap[-1, 0] + \
$inmap[-1, -1] + \
$inmap[0, -1] + \
$inmap[0, 0]) / 4",
"$outmap_C = ($inmap[-1, 1] + \
$inmap[-1, 0] + \
$inmap[0, 0] + \
$inmap[0, 1]) / 4",
"$outmap_D = ($inmap[0, 1] + \
$inmap[0, 0] + \
$inmap[1, 0] + \
$inmap[1, 1]) / 4",
])
grass.mapcalc(
expr,
inmap=r_dsm,
outmap_A=r_a_z,
outmap_B=r_b_z,
outmap_C=r_c_z,
outmap_D=r_d_z,
overwrite=True,
quiet=grass.verbosity() <= 1,
)
attr_map_list.extend([r_a_z, r_b_z, r_c_z, r_d_z])
# Precompute values slopes in e-w direction, n-s direction
# as atan(dz/dx) (e-w direction), atan(dz/dy) (n-s direction)
# using moving window [row, col]
elif pfunction == "Visual_magnitude":
r_slope_ew = "{}_slope_ew".format(TEMPNAME)
r_slope_ns = "{}_slope_ns".format(TEMPNAME)
expr = ";".join([
"$outmap_ew = atan((sqrt(2) * $inmap[-1, 1] + \
2 * $inmap[0, 1] + \
sqrt(2) * $inmap[1, 1] - \
sqrt(2) * $inmap[-1, -1] - \
2 * $inmap[0, -1] - \
sqrt(2) * $inmap[1, -1]) / \
(8 * $w_ew))",
"$outmap_ns = atan((sqrt(2) * $inmap[-1, -1] + \
2 * $inmap[-1, 0] + \
sqrt(2) * $inmap[-1, 1] - \
sqrt(2) * $inmap[1, -1] - \
2 * $inmap[1, 0] - \
sqrt(2) * $inmap[1, 1]) / \
(8 * $w_ns))",
])
grass.mapcalc(
expr,
inmap=r_dsm,
outmap_ew=r_slope_ew,
outmap_ns=r_slope_ns,
w_ew=reg.ewres,
w_ns=reg.nsres,
overwrite=True,
quiet=grass.verbosity() <= 1,
)
attr_map_list.extend([r_slope_ew, r_slope_ns])
# Use viewshed weights if provided
if r_weights:
attr_map_list.append(r_weights)
# Extract attribute values
target_pts_grass = grass.read_command(
"r.what",
flags="v",
map=attr_map_list,
points=v_source_sample,
separator="|",
null_value="*",
quiet=True,
)
# columns to use depending on parametrization function
usecols = list(range(0, 4 + len(attr_map_list)))
usecols.remove(3) # skip 3rd column - site_name
# convert coordinates and attributes of target points T to numpy array
target_pts_np = txt2numpy(
target_pts_grass,
sep="|",
names=None,
null_value="*",
usecols=usecols,
structured=False,
)
# if one point only - 0D array which cannot be used in iteration
if target_pts_np.ndim == 1:
target_pts_np = target_pts_np.reshape(1, -1)
target_pts_np = target_pts_np[~np.isnan(target_pts_np).any(axis=1)]
no_points = target_pts_np.shape[0]
# if viewshed weights not set by flag - set weight to 1 for all pts
if not r_weights:
weights_np = np.ones((no_points, 1))
target_pts_np = np.hstack((target_pts_np, weights_np))
grass.debug("target_pts_np: {}".format(target_pts_np))
# ==========================================================================
# Calculate weighted parametrised cummulative viewshed
# by iterating over target points T
# ==========================================================================
grass.verbose("Calculating partial viewsheds...")
# Parametrisation function
if pfunction == "Solid_angle":
parametrise_viewshed = solid_angle_reverse
elif pfunction == "Distance_decay":
parametrise_viewshed = distance_decay_reverse
elif pfunction == "Fuzzy_viewshed":
parametrise_viewshed = fuzzy_viewshed_reverse
elif pfunction == "Visual_magnitude":
parametrise_viewshed = visual_magnitude_reverse
else:
parametrise_viewshed = binary
# Collect variables that will be used in do_it_all() into a dictionary
global_vars = {
"region": reg,
"range": exp_range,
"param_viewshed": parametrise_viewshed,
"observer_elevation": v_elevation,
"b_1": b_1,
"memory": memory,
"refr_coeff": refr_coeff,
"flagstring": flagstring,
"r_dsm": r_dsm,
"dsm_type": dsm_type,
"cores": cores,
"tempname": TEMPNAME,
}
# Split target points to chunks for each core
target_pnts = np.array_split(target_pts_np, cores)
# Combine each chunk with dictionary
combo = list(zip(itertools.repeat(global_vars), target_pnts))
# Calculate partial cummulative viewshed
with Pool(cores) as pool:
np_sum = pool.starmap(do_it_all, combo)
pool.close()
pool.join()
# We should probably use nansum here?
all_nan = np.all(np.isnan(np_sum), axis=0)
np_sum = np.nansum(np_sum, axis=0, dtype=np.single)
np_sum[all_nan] = np.nan
grass.verbose("Writing final result and cleaning up...")
# Restore original computational region
reg.read()
reg.set_current()
reg.set_raster_region()
# Convert numpy array of cummulative viewshed to raster
numpy2raster(np_sum, mtype="FCELL", rastname=r_output, overwrite=True)
# Remove temporary files and reset mask if needed
cleanup()
# Set raster history to output raster
grass.raster_history(r_output, overwrite=True)
grass.run_command(
"r.support",
overwrite=True,
map=r_output,
title="Visual exposure index as {}".format(pfunction.replace("_",
" ")),
description="generated by r.viewshed.exposure",
units="Index value",
quiet=True,
)
def main():
raster = options["raster"]
maskcats = options["maskcats"]
vector = options["vector"]
layer = options["layer"]
cats = options["cats"]
where = options["where"]
remove = flags["r"]
invert = flags["i"]
if not remove and not raster and not vector:
grass.fatal(
_("Either parameter <raster> or parameter <vector> is required"))
mapset = grass.gisenv()["MAPSET"]
exists = bool(
grass.find_file("MASK", element="cell", mapset=mapset)["file"])
if remove:
# -> remove
if exists:
if sys.platform == "win32":
grass.run_command("g.remove",
flags="if",
quiet=True,
type="raster",
name="MASK")
else:
grass.run_command("g.remove",
flags="f",
quiet=True,
type="raster",
name="MASK")
grass.message(_("Raster MASK removed"))
else:
grass.fatal(_("No existing MASK to remove"))
else:
# -> create
if exists:
if not grass.overwrite():
grass.fatal(
_("MASK already found in current mapset. Delete first or overwrite."
))
else:
grass.warning(_("MASK already exists and will be overwritten"))
grass.run_command("g.remove",
flags="f",
quiet=True,
type="raster",
name="MASK")
if raster:
# check if input raster exists
if not grass.find_file(raster)["file"]:
grass.fatal(_("Raster map <%s> not found") % raster)
if maskcats != "*" and not remove:
if grass.raster_info(raster)["datatype"] != "CELL":
grass.fatal(
_("The raster map <%s> must be integer (CELL type) "
" in order to use the 'maskcats' parameter") %
raster)
p = grass.feed_command("r.reclass",
input=raster,
output="MASK",
overwrite=True,
rules="-")
res = "%s = 1" % maskcats
p.stdin.write(encode(res))
p.stdin.close()
p.wait()
elif vector:
vector_name = grass.find_file(vector, "vector")["fullname"]
if not vector_name:
grass.fatal(_("Vector map <%s> not found") % vector)
# parser bug?
if len(cats) == 0:
cats = None
if len(where) == 0:
where = None
if grass.vector_info_topo(vector_name)["areas"] < 1:
grass.warning(
_("No area found in vector map <%s>. "
"Creating a convex hull for MASK.") % vector_name)
global tmp_hull
tmp_hull = "tmp_hull_%d" % os.getpid()
to_rast_input = tmp_hull
# force 'flat' convex hull for 3D vector maps
try:
grass.run_command(
"v.hull",
flags="f",
quiet=True,
input=vector_name,
output=tmp_hull,
layer=layer,
cats=cats,
where=where,
)
except CalledModuleError:
grass.fatal(
_("Unable to create a convex hull for vector map <%s>")
% vector_name)
else:
to_rast_input = vector_name
env = os.environ.copy()
if grass.verbosity() > 1:
env["GRASS_VERBOSE"] = "1"
grass.run_command(
"v.to.rast",
input=to_rast_input,
layer=layer,
output="MASK",
use="val",
val="1",
type="area",
cats=cats,
where=where,
env=env,
)
if invert:
global tmp
tmp = "r_mask_%d" % os.getpid()
grass.run_command("g.rename", raster=("MASK", tmp), quiet=True)
grass.message(_("Creating inverted raster MASK..."))
grass.mapcalc("MASK = if(isnull($tmp), 1, null())", tmp=tmp)
grass.verbose(_("Inverted raster MASK created"))
else:
grass.verbose(_("Raster MASK created"))
grass.message(
_("All subsequent raster operations will be limited to "
"the MASK area. Removing or renaming raster map named "
"'MASK' will restore raster operations to normal."))
def main():
vector = options["map"]
table = options["table"]
layer = options["layer"]
columns = options["columns"]
key = options["key"]
# does map exist in CURRENT mapset?
mapset = grass.gisenv()["MAPSET"]
if not grass.find_file(vector, element="vector", mapset=mapset)["file"]:
grass.fatal(_("Vector map <%s> not found in current mapset") % vector)
map_name = vector.split("@")[0]
if not table:
if layer == "1":
grass.verbose(
_("Using vector map name as table name: <%s>") % map_name)
table = map_name
else:
# to avoid tables with identical names on higher layers
table = "%s_%s" % (map_name, layer)
grass.verbose(
_("Using vector map name extended by layer number as table name: <%s>"
) % table)
else:
grass.verbose(_("Using user specified table name: %s") % table)
# check if DB parameters are set, and if not set them.
grass.run_command("db.connect", flags="c", quiet=True)
grass.verbose(
_("Creating new DB connection based on default mapset settings..."))
kv = grass.db_connection()
database = kv["database"]
driver = kv["driver"]
schema = kv["schema"]
database2 = database.replace("$MAP/", map_name + "/")
# maybe there is already a table linked to the selected layer?
nuldev = open(os.devnull, "w")
try:
grass.vector_db(map_name, stderr=nuldev)[int(layer)]
grass.fatal(_("There is already a table linked to layer <%s>") % layer)
except KeyError:
pass
# maybe there is already a table with that name?
tables = grass.read_command("db.tables",
flags="p",
database=database2,
driver=driver,
stderr=nuldev)
tables = decode(tables)
if table not in tables.splitlines():
colnames = []
column_def = []
if columns:
column_def = []
for x in " ".join(columns.split()).split(","):
colname = x.lower().split()[0]
if colname in colnames:
grass.fatal(
_("Duplicate column name '%s' not allowed") % colname)
colnames.append(colname)
column_def.append(x)
# if not existing, create it:
if key not in colnames:
column_def.insert(0, "%s integer" % key)
column_def = ",".join(column_def)
grass.verbose(_("Creating table with columns (%s)...") % column_def)
sql = "CREATE TABLE %s (%s)" % (table, column_def)
try:
grass.run_command("db.execute",
database=database2,
driver=driver,
sql=sql)
except CalledModuleError:
grass.fatal(_("Unable to create table <%s>") % table)
# connect the map to the DB:
if schema:
table = "{schema}.{table}".format(schema=schema, table=table)
grass.verbose(_("Connecting new table to vector map <%s>...") % map_name)
grass.run_command(
"v.db.connect",
quiet=True,
map=map_name,
database=database,
driver=driver,
layer=layer,
table=table,
key=key,
)
# finally we have to add cats into the attribute DB to make
# modules such as v.what.rast happy: (creates new row for each
# vector line):
try:
grass.run_command(
"v.to.db",
overwrite=True,
map=map_name,
layer=layer,
option="cat",
column=key,
qlayer=layer,
)
except CalledModuleError:
# remove link
grass.run_command("v.db.connect",
quiet=True,
flags="d",
map=map_name,
layer=layer)
return 1
grass.verbose(_("Current attribute table links:"))
if grass.verbosity() > 2:
grass.run_command("v.db.connect", flags="p", map=map_name)
# write cmd history:
grass.vector_history(map_name)
return 0
def main():
'''
begin main
'''
global soillossbare
global outprefix
global flowaccmethod
global elevation
global kfactor
global rfactor
global resolution
global flowacc
global fieldblock
global fieldblockvect
global flag_r
global quiet
global options
global flags
soillossbare = options['soillossbare']
outprefix = soillossbare + '_'
flowaccmethod = options['flowaccmethod']
flowacc = options['flowacc']
elevation = options['elevation']
kfactor = options['kfactor']
rfactor = options['rfactor']
resolution = options['resolution']
#fieldblock = None
fieldblock = options['fieldblock']
fieldblockvect = options['map']
flag_r = flags['r'] # remove temp maps
quiet = True
if gscript.verbosity() > 2:
quiet=False
gscript.run_command("g.region", flags="a", res=resolution)
if flowacc:
gscript.info("Using flowaccumulation from input raster map %s ..." %flowacc)
ruslealg = rusle_base()
elif flowaccmethod == "r.terraflow":
gscript.info("Using flowaccumulation from module r.terraflow (MFD) ...")
ruslealg = rusle_terraflow()
elif flowaccmethod == "r.flow":
gscript.info("Using flowaccumulation from module r.flow (SFD) ...")
ruslealg = rusle_flow()
elif flowaccmethod == "r.watershed":
gscript.info("Using flowaccumulation from module r.watershed (MFD) ...")
ruslealg = rusle_watershed()
p = ruslealg.rusle()
if flag_r:
#remove = ruslealg.removeTempRasters() # already in destructor
pass
return
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 main():
# Get the options
input = options["input"]
input_name = input.split('@')[0]
output = options["output"]
method = options["method"]
min_cat = None
max_cat = None
point = None
overwrite = grass.overwrite()
quiet = True
if grass.verbosity() > 2:
quiet = False
in_info = grass.vector_info(input)
# check for wild mixture of vector types
if in_info['points'] > 0 and in_info['boundaries'] > 0:
grass.fatal(_("The input vector map contains both polygons and points,"
" cannot handle mixed types"))
pid = os.getpid()
# process points via triangulation, then exit
if in_info['points'] > 0:
point = True
layer = 1 # hardcoded for now
out_temp = '{inp}_point_tmp_{pid}'.format(inp=input_name, pid=pid)
if method == 'delaunay':
grass.message(_("Processing point data (%d points found)...") % in_info['points'])
grass.run_command('v.delaunay', input=input, layer=layer,
output=out_temp, quiet=quiet)
grass.run_command('v.db.addtable', map=out_temp, quiet=True)
input = out_temp
in_info = grass.vector_info(input)
# process areas
if in_info['areas'] == 0 and in_info['boundaries'] == 0:
grass.fatal(_("The input vector map does not contain polygons"))
out_type = '{inp}_type_{pid}'.format(inp=input_name, pid=pid)
input_tmp = '{inp}_tmp_{pid}'.format(inp=input_name, pid=pid)
remove_names = "%s,%s" % (out_type, input_tmp)
grass.message(_("Processing area data (%d areas found)...") % in_info['areas'])
try:
grass.run_command('v.category', layer="2", type='boundary',
option='add', input=input, out=input_tmp,
quiet=quiet)
except CalledModuleError:
grass.run_command('g.remove', flags='f', type='vector',
name=input_tmp, quiet=quiet)
grass.fatal(_("Error creating layer 2"))
try:
grass.run_command('v.db.addtable', map=input_tmp, layer="2",
quiet=quiet)
except CalledModuleError:
grass.run_command('g.remove', flags='f', type='vector',
name=input_tmp, quiet=quiet)
grass.fatal(_("Error creating new table for layer 2"))
try:
grass.run_command('v.to.db', map=input_tmp, option="sides",
columns="left,right", layer="2", quiet=quiet)
except CalledModuleError:
grass.run_command('g.remove', flags='f', type='vector',
name=input_tmp, quiet=quiet)
grass.fatal(_("Error populating new table for layer 2"))
try:
grass.run_command('v.type', input=input_tmp, output=out_type,
from_type='boundary', to_type='line',
quiet=quiet, layer="2")
except CalledModuleError:
grass.run_command('g.remove', flags='f', type='vector',
name=remove_names, quiet=quiet)
grass.fatal(_("Error converting polygon to line"))
report = grass.read_command('v.category', flags='g', input=out_type,
option='report', quiet=quiet)
report = decode(report).split('\n')
for r in report:
if r.find('centroid') != -1:
min_cat = report[0].split()[-2]
max_cat = report[0].split()[-1]
break
if min_cat and max_cat:
try:
grass.run_command('v.edit', map=out_type, tool='delete',
type='centroid', layer=2, quiet=quiet,
cats='{mi}-{ma}'.format(mi=min_cat, ma=max_cat))
except CalledModuleError:
grass.run_command('g.remove', flags='f', type='vector',
name=remove_names, quiet=quiet)
grass.fatal(_("Error removing centroids"))
try:
try:
# TODO: fix magic numbers for layer here and there
grass.run_command('v.db.droptable', map=out_type, layer=1,
flags='f', quiet=True)
except CalledModuleError:
grass.run_command('g.remove', flags='f', type='vector',
name=remove_names, quiet=quiet)
grass.fatal(_("Error removing table from layer 1"))
# TODO: when this except is happaning, it seems that never, so it seems wrong
except:
grass.warning(_("No table for layer %d" % 1))
try:
grass.run_command('v.category', input=out_type, option='transfer',
output=output, layer="2,1", quiet=quiet,
overwrite=overwrite)
except CalledModuleError:
grass.run_command('g.remove', flags='f', type='vector',
name=remove_names, quiet=quiet)
grass.fatal(_("Error adding categories"))
grass.run_command('g.remove', flags='f', type='vector',
name=remove_names, quiet=quiet)
if point:
grass.run_command('g.remove', flags='f', type='vector',
name=out_temp, quiet=quiet)
def main():
# Get the options
input = options["input"]
output = options["output"]
strds = options["strds"]
tempwhere = options["t_where"]
where = options["where"]
methods = options["method"]
percentile = options["percentile"]
overwrite = grass.overwrite()
quiet = True
if grass.verbosity() > 2:
quiet = False
if where == "" or where == " " or where == "\n":
where = None
# Check the number of sample strds and the number of columns
strds_names = strds.split(",")
# Make sure the temporal database exists
tgis.init()
# We need a database interface
dbif = tgis.SQLDatabaseInterfaceConnection()
dbif.connect()
samples = []
first_strds = tgis.open_old_stds(strds_names[0], "strds", dbif)
# Single space time raster dataset
if len(strds_names) == 1:
granu = first_strds.get_granularity()
rows = first_strds.get_registered_maps(
"name,mapset,start_time,end_time", tempwhere, "start_time", dbif)
if not rows:
dbif.close()
grass.fatal(
_("Space time raster dataset <%s> is empty") %
first_strds.get_id())
for row in rows:
start = row["start_time"]
end = row["end_time"]
raster_maps = [
row["name"] + "@" + row["mapset"],
]
s = Sample(start, end, raster_maps, first_strds.get_name(), granu)
samples.append(s)
else:
# Multiple space time raster datasets
for name in strds_names[1:]:
dataset = tgis.open_old_stds(name, "strds", dbif)
if dataset.get_temporal_type() != first_strds.get_temporal_type():
grass.fatal(
_(
"Temporal type of space time raster "
"datasets must be equal\n<%(a)s> of type "
"%(type_a)s do not match <%(b)s> of type "
"%(type_b)s" % {
"a": first_strds.get_id(),
"type_a": first_strds.get_temporal_type(),
"b": dataset.get_id(),
"type_b": dataset.get_temporal_type()
}))
mapmatrizes = tgis.sample_stds_by_stds_topology(
"strds", "strds", strds_names, strds_names[0], False, None,
"equal", False, False)
#TODO check granularity for multiple STRDS
for i in range(len(mapmatrizes[0])):
isvalid = True
mapname_list = []
for mapmatrix in mapmatrizes:
entry = mapmatrix[i]
if entry["samples"]:
sample = entry["samples"][0]
name = sample.get_id()
if name is None:
isvalid = False
break
else:
mapname_list.append(name)
if isvalid:
entry = mapmatrizes[0][i]
map = entry["granule"]
start, end = map.get_temporal_extent_as_tuple()
s = Sample(start, end, mapname_list, name)
samples.append(s)
# Get the layer and database connections of the input vector
if where:
try:
grass.run_command("v.extract",
input=input,
where=where,
output=output)
except CalledModuleError:
dbif.close()
grass.fatal(
_("Unable to run v.extract for vector map"
" <%s> and where <%s>") % (input, where))
else:
gcopy(input, output, 'vector')
msgr = Messenger()
perc_curr = 0
perc_tot = len(samples)
pymap = Vector(output)
try:
pymap.open('r')
except:
dbif.close()
grass.fatal(_("Unable to create vector map <%s>" % output))
pymap.close()
for sample in samples:
raster_names = sample.raster_names
# Call v.what.rast for each raster map
for name in raster_names:
day = sample.printDay()
column_name = "%s_%s" % (sample.strds_name, day)
try:
grass.run_command("v.rast.stats",
map=output,
raster=name,
column=column_name,
method=methods,
percentile=percentile,
quiet=quiet,
overwrite=overwrite)
except CalledModuleError:
dbif.close()
grass.fatal(
_("Unable to run v.what.rast for vector map"
" <%s> and raster map <%s>") % (output, name))
msgr.percent(perc_curr, perc_tot, 1)
perc_curr += 1
dbif.close()
def main():
vector = options['map']
table = options['table']
layer = options['layer']
columns = options['columns']
key = options['key']
# does map exist in CURRENT mapset?
mapset = grass.gisenv()['MAPSET']
if not grass.find_file(vector, element='vector', mapset=mapset)['file']:
grass.fatal(_("Vector map <%s> not found in current mapset") % vector)
map_name = vector.split('@')[0]
if not table:
if layer == '1':
grass.verbose(_("Using vector map name as table name: <%s>") % map_name)
table = map_name
else:
# to avoid tables with identical names on higher layers
table = "%s_%s" % (map_name, layer)
grass.verbose(
_("Using vector map name extended by layer number as table name: <%s>") %
table)
else:
grass.verbose(_("Using user specified table name: %s") % table)
# check if DB parameters are set, and if not set them.
grass.run_command('db.connect', flags='c')
grass.verbose(_("Creating new DB connection based on default mapset settings..."))
kv = grass.db_connection()
database = kv['database']
driver = kv['driver']
schema = kv['schema']
# maybe there is already a table linked to the selected layer?
nuldev = file(os.devnull, 'w')
try:
grass.vector_db(map_name, stderr=nuldev)[int(layer)]
grass.fatal(_("There is already a table linked to layer <%s>") % layer)
except KeyError:
pass
# maybe there is already a table with that name?
tables = grass.read_command('db.tables', flags='p', database=database, driver=driver,
stderr=nuldev)
if not table in tables.splitlines():
if columns:
column_def = [x.strip().lower() for x in columns.strip().split(',')]
else:
column_def = []
# if not existing, create it:
column_def_key = "%s integer" % key
if column_def_key not in column_def:
column_def.insert(0, column_def_key)
column_def = ','.join(column_def)
grass.verbose(_("Creating table with columns (%s)...") % column_def)
sql = "CREATE TABLE %s (%s)" % (table, column_def)
try:
grass.run_command('db.execute',
database=database, driver=driver, sql=sql)
except CalledModuleError:
grass.fatal(_("Unable to create table <%s>") % table)
# connect the map to the DB:
if schema:
table = '{schema}.{table}'.format(schema=schema, table=table)
grass.run_command('v.db.connect', quiet=True,
map=map_name, database=database, driver=driver,
layer=layer, table=table, key=key)
# finally we have to add cats into the attribute DB to make modules such as v.what.rast happy:
# (creates new row for each vector line):
grass.run_command('v.to.db', map=map_name, layer=layer,
option='cat', column=key, qlayer=layer)
grass.verbose(_("Current attribute table links:"))
if grass.verbosity() > 2:
grass.run_command('v.db.connect', flags='p', map=map_name)
# write cmd history:
grass.vector_history(map_name)
return 0
def main():
'''
begin main
'''
global soillossbare
global outprefix
global flowaccmethod
global elevation
global kfactor
global rfactor
global resolution
global flowacc
global fieldblock
global fieldblockvect
global flag_r
global quiet
global options
global flags
soillossbare = options['soillossbare']
outprefix = soillossbare + '_'
flowaccmethod = options['flowaccmethod']
flowacc = options['flowacc']
elevation = options['elevation']
kfactor = options['kfactor']
rfactor = options['rfactor']
resolution = options['resolution']
#fieldblock = None
fieldblock = options['fieldblock']
fieldblockvect = options['map']
flag_r = flags['r'] # remove temp maps
quiet = True
if g.verbosity() > 2:
quiet = False
g.run_command("g.region", flags="a", res=resolution)
if flowacc:
g.info("Using flowaccumulation from input raster map %s ..." % flowacc)
ruslealg = rusle_base()
elif flowaccmethod == "r.terraflow":
g.info("Using flowaccumulation from module r.terraflow (MFD) ...")
ruslealg = rusle_terraflow()
elif flowaccmethod == "r.flow":
g.info("Using flowaccumulation from module r.flow (SFD) ...")
ruslealg = rusle_flow()
elif flowaccmethod == "r.watershed":
g.info("Using flowaccumulation from module r.watershed (MFD) ...")
ruslealg = rusle_watershed()
p = ruslealg.rusle()
if flag_r:
remove = ruslealg.removeTempRasters()
return
def main():
soilloss = options['soilloss']
soilloss9 = soilloss.split('@')[0] + '.9'
soilloss3 = soilloss.split('@')[0] + '.3'
colorschema = options['colorschema']
flag_u = flags['u']
flag_f = flags['f']
quiet = True
if gscript.verbosity() > 2:
quiet=False
#color shemes - contents:
classrules = { 'soillossbare9' : {},
'soillossbare3' : {},
'soillossgrow9' : {},
'cfactor6' : {},
'kfactor6' : {}
}
colorrules = { 'soillossbare9': {},
'soillossbare3': {},
'soillossbare' : {},
'soillossgrow9' : {},
'soillossgrow' : {},
'cfactor6' : {},
'cfactor' : {},
'kfactor6' : {},
'kfactor' : {}
}
# (c) Gisler 2010
classrules['soillossbare9'] = '\n '.join([
"0 thru 20 = 1 < 20",
"20 thru 30 = 2 20 - 30",
"30 thru 40 = 3 30 - 40",
"40 thru 55 = 4 40 - 55",
"55 thru 100 = 5 55 - 100",
"100 thru 150 = 6 100 - 150",
"150 thru 250 = 7 150 - 250",
"250 thru 500 = 8 250 - 500",
"500 thru 50000 = 9 > 500",
])
# (c) Gisler 2010
classrules['soillossbare3'] = '\n '.join([
"0 thru 30 = 1 keine Gefährdung",
"30 thru 55 = 2 Gefährdung",
"55 thru 50000 = 3 grosse Gefährdung",
])
# (c) BLW 2011
colorrules['soillossbare9'] = '\n '.join([
"1 0:102:0",
"2 51:153:0",
"3 204:255:0",
"4 255:255:0",
"5 255:102:0",
"6 255:0:0",
"7 204:0:0",
"8 153:0:0",
"9 102:0:0",
])
# (c) BLW 2011
colorrules['soillossbare3'] = '\n '.join([
"1 51:153:0",
"2 255:255:0",
"3 255:0:0"
])
# (c) BLW 2011
colorrules['soillossbare'] = '\n '.join([
"0 0:102:0",
"20 51:153:0",
"30 204:255:0",
"40 255:255:0",
"55 255:102:0",
"100 255:0:0",
"150 204:0:0",
"250 153:0:0",
"500 102:0:0",
"5000 102:0:0"
])
# (c) Gisler 2010
colorrules['soillossgrow9'] = '\n '.join([
"1 69:117:183",
"2 115:146:185",
"3 163:179:189",
"4 208:216:193",
"5 255:255:190",
"6 252:202:146",
"7 245:153:106",
"8 233:100:70",
"9 213:47:39"
])
# (c) Gisler 2010
colorrules['soillossgrow9'] = '\n '.join([
"1 69:117:183",
"2 115:146:185",
"3 163:179:189",
"4 208:216:193",
"5 255:255:190",
"6 252:202:146",
"7 245:153:106",
"8 233:100:70",
"9 213:47:39"
])
# (c) Gisler 2010
colorrules['soillossgrow3'] = '\n '.join([
"1 69:117:183",
"2 163:179:189",
"3 208:216:193",
"4 245:153:106"
])
# (c) Gisler 2010
colorrules['soillossgrow'] = '\n '.join([
"0 69:117:183",
"1 115:146:185",
"2 163:179:189",
"4 208:216:193",
"7.5 255:255:190",
"10 252:202:146",
"15 245:153:106",
"20 233:100:70",
"30 213:47:39",
"300 213:47:39"
])
# (c) Gisler 2010
classrules['soillossgrow9'] = '\n '.join([
"0 thru 1 = 1 < 1 ",
"1 thru 2 = 2 1 - 2 ",
"2 thru 4 = 3 2 - 4 ",
"4 thru 7.5 = 4 4 - 7.5",
"7.5 thru 10 = 5 7.5 - 10",
"10 thru 15 = 6 10 - 15",
"15 thru 20 = 7 15 - 20",
"20 thru 30 = 8 20 - 30",
"30 thru 5000 = 9 > 30"
])
# (c) Gisler 2010
classrules['soillossgrow3'] = '\n '.join([
"0 thru 2 = 1 Toleranz mittelgründige Böden",
"2 thru 4 = 2 Toleranz tiefgründige Böden",
"4 thru 7.5 = 3 leichte Überschreitung",
"7.5 thru 5000 = 4 starke Überschreitung"
])
# Gisler 2010
colorrules['cfactor6'] = '\n '.join([
"1 56:145:37",
"2 128:190:91",
"3 210:233:153",
"4 250:203:147",
"5 225:113:76",
"6 186:20:20"
])
# Gisler 2010
colorrules['cfactor'] = '\n '.join([
"0.00 56:145:37",
"0.01 128:190:91",
"0.05 210:233:153",
"0.1 250:203:147",
"0.15 225:113:76",
"0.2 186:20:20",
"1 186:20:20",
])
# (c) Gisler 2010
classrules['kfactor5'] = '\n '.join([
"0 thru 0.20 = 1 < 0.20",
"0.20 thru 0.25 = 2 0.20 - 0.25",
"0.25 thru 0.30 = 3 0.25 - 0.3",
"0.3 thru 0.35 = 4 0.3 - 0.35",
"0.35 thru 1 = 5 > 0.30"
])
# (c) Gisler 2010
colorrules['kfactor6'] = '\n '.join([
"1 15:70:15",
"2 98:131:52",
"3 204:204:104",
"4 151:101:50",
"5 98:21:15"
])
# (c) Gisler 2010
colorrules['kfactor'] = '\n '.join([
"0.00 15:70:15",
"0.20 98:131:52",
"0.25 204:204:104",
"0.30 151:101:50",
"0.35 98:21:15"
])
# own definitions
colorrules['cpmax'] = '\n '.join([
"0.01 102:0:0",
"0.01 153:0:0",
"0.02 204:0:0",
"0.04 255:0:0",
"0.06 255:102:0",
"0.08 255:255:0",
"0.10 204:255:0",
"0.12 51:153:0",
"0.15 0:102:0",
"1000.00 0:102:0"
])
classrules9 = '\n '.join([
"0 thru 20 = 1 <20",
"20 thru 30 = 2 20 - 30",
"30 thru 40 = 3 30 - 40",
"40 thru 55 = 4 40 - 55",
"55 thru 100 = 5 55 - 100",
"100 thru 150 = 6 100 - 150",
"150 thru 250 = 7 150 - 250",
"250 thru 500 = 8 250 - 500",
"500 thru 50000 = 9 >500",
])
if colorschema == 'soillossbare':
classrules9 = classrules['soillossbare9']
colorrules9 = colorrules['soillossbare9']
classrules3 = classrules['soillossbare3']
colorrules3 = colorrules['soillossbare3']
colorrules = colorrules['soillossbare']
if colorschema == 'soillossgrow':
classrules9 = classrules['soillossgrow9']
colorrules9 = colorrules['soillossgrow9']
classrules3 = classrules['soillossgrow3']
colorrules3 = colorrules['soillossgrow3']
colorrules = colorrules['soillossgrow']
r.reclass(input=soilloss, rules='-', stdin = classrules9, output=soilloss9)
r.colors(map = soilloss9, rules = '-', stdin = colorrules9, quiet = quiet)
r.reclass(input=soilloss, rules='-', stdin = classrules3, output=soilloss3)
r.colors(map = soilloss3, rules = '-', stdin = colorrules3, quiet = quiet)
if flag_f:
soilloss3f = soilloss3 + 'f'
r.neighbors(method='mode', input=soilloss3, selection=soilloss3,
output=soilloss3f, size=7)
soilloss3 = soilloss3f
if flag_u:
r.colors(map = soilloss, rules = '-', stdin = colorrules, quiet = quiet)
def main():
# parameters
infile = options['input']
raster_reference = options['raster_reference']
raster_file = options['raster_file']
outfiles = options['output']
resolution = options['resolution']
methods = options['method']
zrange = options['zrange']
zscale = options['zscale']
output_type = options['type']
percent = options['percent']
pth = options['pth']
trim = options['trim']
footprint = options['footprint']
# flags
scan = flags['s']
shell_script_style = flags['g']
if len(outfiles.split(",")) != len(methods.split(",")):
grass.fatal(
_("Number of outputs <%s> does not match number of methods <%s>" %
(outfiles, methods)))
# overwrite auf true setzen
os.environ['GRASS_OVERWRITE'] = '1'
# to hide non-error messages from subprocesses
if grass.verbosity() <= 2:
outdev = open(os.devnull, 'w')
else:
outdev = sys.stdout
# use temporary region
grass.use_temp_region()
n, s, w, e, t, b = scan_extent(infile)
# scan -s or shell_script_style -g:
if scan:
if not shell_script_style:
grass.message(
_("north: %s\nsouth: %s\nwest: %s\neast: %s\ntop: %s\nbottom: %s"
) % (n, s, w, e, t, b))
else:
# shell script style: print to stdout
print("n=%s s=%s w=%s e=%s t=%s b=%s" % (n, s, w, e, t, b))
elif footprint:
footprint_to_vectormap(infile, footprint)
else:
# get region with pdal
#footprint_to_vectormap(infile, 'tiles')
if raster_file:
raster_reference = 'img' + str(os.getpid())
grass.run_command('r.external',
input=raster_file,
flags='o',
output=raster_reference)
result = grass.find_file(name=raster_reference, element='raster')
if result[u'fullname'] == u'':
raster_reference = raster_reference + '.1'
# option 1: set region to extent of tiles while precisely aligning pixel
# geometry to raster_reference (including both raster_reference and raster_file)
if raster_reference:
grass.run_command('g.region',
n=n,
s=s,
e=e,
w=w,
flags='g',
align=raster_reference)
else:
# option 2: change raster resolution to final resolution while best
# effort aligning to pixel geometry
grass.run_command('g.region',
n=n,
s=s,
e=e,
w=w,
flags='ap',
res=resolution)
# generate PDAL pipeline
# . pdal pipline laz2json (STDOUT) | r.in.xyz
bn = os.path.basename(infile)
infile_format = bn.split('.')[-1]
# format_reader from https://pdal.io/stages/readers.html
format_reader = ''
if infile_format.lower() == 'laz' or infile_format.lower() == 'las':
format_reader = 'readers.las'
# pts: not tested
elif infile_format.lower() == 'pts':
format_reader = 'readers.pts'
else:
grass.run_command('g.remove',
flags='f',
type='vector',
name='tiles',
quiet=True)
grass.fatal(_("Format .%s is not supported.." % infile_format))
grass.message(_("Converting input file <%s>...") % infile)
tmp_file_json = 'tmp_file_json_' + str(os.getpid())
data = {}
data['pipeline'] = []
data['pipeline'].append({'type': format_reader, 'filename': infile})
data['pipeline'].append({
'type': 'writers.text',
'format': 'csv',
'order': 'X,Y,Z',
'keep_unspecified': 'false',
'filename': 'STDOUT',
'quote_header': 'false'
})
with open(tmp_file_json, 'w') as f:
json.dump(data, f)
tmp_xyz = grass.tempfile()
if tmp_xyz is None:
grass.fatal("Unable to create temporary files")
command_pdal1 = options['pdal_cmd'].split(' ')
if options['pdal_cmd'] != 'pdal':
v_index = None
cmd_entries = options['pdal_cmd'].split(' ')
for cmd_entry, num in zip(cmd_entries, range(len(cmd_entries))):
if cmd_entry == '-v':
v_index = num
break
mnt_vol = cmd_entries[v_index + 1].split(':')[1]
tmp_file_json2 = os.path.join(mnt_vol, tmp_file_json)
else:
tmp_file_json2 = tmp_file_json
command_pdal1.extend(['pipeline', '--input', tmp_file_json2])
fh = open(tmp_xyz, 'wb')
if grass.call(command_pdal1, stdout=fh) != 0:
fh.close()
# check to see if pdal pipeline executed properly
print(command_pdal1)
grass.fatal(_("pdal pipeline is broken..."))
else:
fh.close()
for i in range(len(methods.split(","))):
method = methods.split(",")[i]
outfile = outfiles.split(",")[i]
grass.message(_("Generating output raster map <%s>...") % outfile)
command_pdal2 = [
'r.in.xyz', 'input=' + tmp_xyz, 'output=' + outfile, 'skip=1',
'separator=comma', 'method=' + method
]
if zrange:
command_pdal2.append('zrange=' + zrange)
if zscale:
command_pdal2.append('zscale=' + zscale)
if output_type:
command_pdal2.append('type=' + output_type)
if percent:
command_pdal2.append('percent=' + percent)
if pth:
command_pdal2.append('pth=' + pth)
if trim:
command_pdal2.append('trim=' + trim)
if grass.call(command_pdal2, stdout=outdev) != 0:
# check to see if r.in.xyz executed properly
os.remove(tmp_xyz)
grass.fatal(_("r.in.xyz is broken..."))
# metadata
empty_history = grass.tempfile()
if empty_history is None:
grass.fatal("Unable to create temporary files")
f = open(empty_history, 'w')
f.close()
grass.run_command('r.support',
map=outfile,
source1=infile,
description='generated by r.in.pdal',
loadhistory=empty_history)
grass.run_command('r.support',
map=outfile,
history=os.environ['CMDLINE'])
os.remove(empty_history)
# Cleanup
grass.message(_("Cleaning up..."))
grass.run_command('g.remove',
flags='f',
type='vector',
name='tiles',
quiet=True)
if raster_file:
grass.run_command('g.remove',
flags='f',
type='raster',
pattern=raster_reference[:-1] + '*',
quiet=True)
os.remove(tmp_file_json)
os.remove(tmp_xyz)
grass.del_temp_region()
def main(options, flags):
configuration = options['configuration']
output = options['output']
betriebid = options['betriebid']
task = options['task']
username = options['username']
password = options['password']
maxsoilloss = options['maxsoilloss']
flag_b = flags['b'] #use newly defined barriers
flag_g = flags['g'] #don't set region according to parcel data
flag_i = flags['i'] #force reimport of base data
flag_n = flags['n'] #don't import anything (offline mode)
flag_c = flags['c'] #don't copy results to output raster map
flag_s = flags['s'] #calculate statistics for results
flag_v = flags['v'] #verbose
flag_o = flags['o'] #overwrite
#os.path.expanduser(path)
env = gscript.parse_command("g.gisenv", flags='s')
gisdbase = env['GISDBASE'].strip(";'").lstrip("'")
location = env['LOCATION_NAME'].strip(";'").lstrip("'")
mapset = env['MAPSET'].strip(";'").lstrip("'")
try:
gislock = os.path.join(gisdbase,location,mapset,'.gislock')
os.remove(gislock)
except OSError:
pass
gcommands = []
#gcommands += ['g.version']
#gcommands += ['g.mapset %s --q' %mapset]
gcommands += ['db.connect -d --q']
if flag_v:
gcommands += ['g.gisenv']
gexecute = 'g.gui.soilloss output='+output +' betriebid=' + betriebid \
+ ' task=' + task + ' maxsoilloss=' + maxsoilloss + ' username='******' password='******' -b'
if flag_s: gexecute += ' -s'
if flag_i: gexecute += ' -i'
if flag_n: gexecute += ' -n'
if flag_o: gexecute += ' --o'
if gscript.overwrite(): gexecute += ' --o'
if gscript.verbosity() > 2 or flag_v: gexecute += ' --v'
else: gexecute += ' --q'
gcommands += [gexecute]
gcommands += ['exit']
batchjob = os.getenv('HOME') + '/.qgis2/processing/grass7_batch_job.sh'
with open(batchjob, 'w') as f:
for s in gcommands:
print s
f.write(s + '\n')
f.close()
rclines = []
rclines += ['MAPSET: ' + mapset]
rclines += ['GISDBASE: ' + gisdbase]
rclines += ['LOCATION_NAME: ' + location]
rclines += ['GUI: text']
rcfile = os.getenv('HOME') + '/.grass7/rc'
with open(rcfile, 'w') as f:
for s in rclines:
print s
f.write(s + '\n')
f.close()
st = os.stat(batchjob)
os.chmod(batchjob, st.st_mode | 0111)
os.environ['GRASS_BATCH_JOB'] = batchjob
del os.environ['LD_LIBRARY_PATH']
del os.environ['GISBASE']
command = ['grass70 '] + [gisdbase + '/' \
+ location + '/' + mapset]
subprocess.call(command, shell=True)
def main():
# parameters
infile = options['input']
raster_reference = options['raster_reference']
raster_file = options['raster_file']
outfile = options['output']
resolution = options['resolution']
method = options['method']
zrange = options['zrange']
zscale = options['zscale']
output_type = options['type']
percent = options['percent']
pth = options['pth']
trim = options['trim']
footprint = options['footprint']
# flags
scan = flags['s']
shell_script_style = flags['g']
# overwrite auf true setzen
os.environ['GRASS_OVERWRITE'] = '1'
# to hide non-error messages from subprocesses
if grass.verbosity() <= 2:
outdev = open(os.devnull, 'w')
else:
outdev = sys.stdout
# use temporary region
grass.use_temp_region()
# scan -s or shell_script_style -g:
if scan:
if not grass.find_program(
options['pdal_cmd'].split(' ')[0],
' '.join(options['pdal_cmd'].split(' ')[1:]) +
' info --summary'):
grass.fatal(
_("The pdal program is not in the path " +
"and executable. Please install first"))
command_scan = options['pdal_cmd'].split(' ')
command_scan.extend(['info', '--summary', infile])
tmp_scan = grass.tempfile()
if tmp_scan is None:
grass.fatal("Unable to create temporary files")
fh = open(tmp_scan, 'wb')
summary = True
if grass.call(command_scan, stdout=fh) != 0:
fh.close()
command_scan = options['pdal_cmd'].split(' ')
command_scan.extend(['info', infile])
fh2 = open(tmp_scan, 'wb')
if grass.call(command_scan, stdout=fh2) != 0:
os.remove(tmp_scan)
grass.fatal(
_("pdal cannot determine metadata " +
"for unsupported format of <%s>") % infile)
fh2.close()
else:
fh2.close()
summary = False
else:
fh.close()
data = json.load(open(tmp_scan))
if summary:
str1 = u'summary'
str2 = u'bounds'
y_str = u'Y'
x_str = u'X'
z_str = u'Z'
min_str = u'min'
max_str = u'max'
try:
n = str(data[str1][str2][y_str][max_str])
s = str(data[str1][str2][y_str][min_str])
w = str(data[str1][str2][x_str][min_str])
e = str(data[str1][str2][x_str][max_str])
t = str(data[str1][str2][z_str][max_str])
b = str(data[str1][str2][z_str][min_str])
except:
ymin_str = u'miny'
xmin_str = u'minx'
zmin_str = u'minz'
ymax_str = u'maxy'
xmax_str = u'maxx'
zmax_str = u'maxz'
n = str(data[str1][str2][ymax_str])
s = str(data[str1][str2][ymin_str])
w = str(data[str1][str2][xmin_str])
e = str(data[str1][str2][xmax_str])
t = str(data[str1][str2][zmax_str])
b = str(data[str1][str2][zmin_str])
else:
str1 = u'stats'
str2 = u'bbox'
str3 = u'native'
str4 = u'bbox'
n = str(data[str1][str2][str3][str4][u'maxy'])
s = str(data[str1][str2][str3][str4][u'miny'])
w = str(data[str1][str2][str3][str4][u'minx'])
e = str(data[str1][str2][str3][str4][u'maxx'])
t = str(data[str1][str2][str3][str4][u'maxz'])
b = str(data[str1][str2][str3][str4][u'minz'])
if not shell_script_style:
grass.message(
_("north: %s\nsouth: %s\nwest: %s\neast: %s\ntop: %s\nbottom: %s"
) % (n, s, w, e, t, b))
else:
grass.message(
_("n=%s s=%s w=%s e=%s t=%s b=%s") % (n, s, w, e, t, b))
elif footprint:
footprint_to_vectormap(infile, footprint)
else:
# get region with pdal
footprint_to_vectormap(infile, 'tiles')
if raster_file:
raster_reference = 'img' + str(os.getpid())
grass.run_command('r.external',
input=raster_file,
flags='o',
output=raster_reference)
result = grass.find_file(name=raster_reference, element='raster')
if result[u'fullname'] == u'':
raster_reference = raster_reference + '.1'
# option 1: set region to extent of tiles while precisely aligning pixel
# geometry to raster_reference (including both raster_reference and raster_file)
if raster_reference:
grass.run_command('g.region',
vector='tiles',
flags='g',
align=raster_reference)
else:
# option 2: change raster resolution to final resolution while best
# effort aligning to pixel geometry
grass.run_command('g.region',
vector='tiles',
flags='ap',
res=resolution)
# generate PDAL pipeline
# . pdal pipline laz2json (STDOUT) | r.in.xyz
bn = os.path.basename(infile)
infile_format = bn.split('.')[-1]
# format_reader from https://pdal.io/stages/readers.html
format_reader = ''
if infile_format.lower() == 'laz' or infile_format.lower() == 'las':
format_reader = 'readers.las'
# pts: not tested
elif infile_format.lower() == 'pts':
format_reader = 'readers.pts'
else:
grass.run_command('g.remove',
flags='f',
type='vector',
name='tiles',
quiet=True)
grass.fatal(_("Format .%s is not supported.." % infile_format))
tmp_file_json = 'tmp_file_json_' + str(os.getpid())
data = {}
data['pipeline'] = []
data['pipeline'].append({'type': format_reader, 'filename': infile})
data['pipeline'].append({
'type': 'writers.text',
'format': 'csv',
'order': 'X,Y,Z',
'keep_unspecified': 'false',
'filename': 'STDOUT',
'quote_header': 'false'
})
with open(tmp_file_json, 'w') as f:
json.dump(data, f)
tmp_xyz = grass.tempfile()
if tmp_xyz is None:
grass.fatal("Unable to create temporary files")
command_pdal1 = options['pdal_cmd'].split(' ')
if options['pdal_cmd'] != 'pdal':
v_index = None
cmd_entries = options['pdal_cmd'].split(' ')
for cmd_entry, num in zip(cmd_entries, range(len(cmd_entries))):
if cmd_entry == '-v':
v_index = num
break
mnt_vol = cmd_entries[v_index + 1].split(':')[1]
tmp_file_json2 = os.path.join(mnt_vol, tmp_file_json)
else:
tmp_file_json2 = tmp_file_json
command_pdal1.extend(['pipeline', '--input', tmp_file_json2])
command_pdal2 = [
'r.in.xyz', 'input=' + tmp_xyz, 'output=' + outfile, 'skip=1',
'separator=comma', 'method=' + method
]
if zrange:
command_pdal2.append('zrange=' + zrange)
if zscale:
command_pdal2.append('zscale=' + zscale)
if output_type:
command_pdal2.append('type=' + output_type)
if percent:
command_pdal2.append('percent=' + percent)
if pth:
command_pdal2.append('pth=' + pth)
if trim:
command_pdal2.append('trim=' + trim)
fh = open(tmp_xyz, 'wb')
if grass.call(command_pdal1, stdout=fh) != 0:
fh.close()
# check to see if pdal pipeline executed properly
grass.fatal(_("pdal pipeline is broken..."))
else:
fh.close()
if grass.call(command_pdal2, stdout=outdev) != 0:
# check to see if r.in.xyz executed properly
os.remove(tmp_xyz)
grass.fatal(_("r.in.xyz is broken..."))
# metadata
empty_history = grass.tempfile()
if empty_history is None:
grass.fatal("Unable to create temporary files")
f = open(empty_history, 'w')
f.close()
grass.run_command('r.support',
map=outfile,
source1=infile,
description='generated by r.in.pdal',
loadhistory=empty_history)
grass.run_command('r.support',
map=outfile,
history=os.environ['CMDLINE'])
os.remove(empty_history)
# Cleanup
grass.message(_("Cleaning up..."))
grass.run_command('g.remove',
flags='f',
type='vector',
name='tiles',
quiet=True)
if raster_file:
grass.run_command('g.remove',
flags='f',
type='raster',
pattern=raster_reference[:-1] + '*',
quiet=True)
os.remove(tmp_file_json)
os.remove(tmp_xyz)
grass.message(_("Generating output raster map <%s>...") % outfile)
grass.del_temp_region()
def main():
# lazy imports
import grass.temporal as tgis
from grass.pygrass.utils import copy as gcopy
from grass.pygrass.messages import Messenger
from grass.pygrass.vector import Vector
# Get the options
input = options["input"]
output = options["output"]
strds = options["strds"]
where = options["where"]
tempwhere = options["t_where"]
if output and flags['u']:
grass.fatal(_("Cannot combine 'output' option and 'u' flag"))
elif not output and not flags['u']:
grass.fatal(_("'output' option or 'u' flag must be given"))
elif not output and flags['u']:
grass.warning(
_("Attribute table of vector {name} will be updated...").format(
name=input))
if where == "" or where == " " or where == "\n":
where = None
overwrite = grass.overwrite()
quiet = True
if grass.verbosity() > 2:
quiet = False
# Check the number of sample strds and the number of columns
strds_names = strds.split(",")
# Make sure the temporal database exists
tgis.init()
# We need a database interface
dbif = tgis.SQLDatabaseInterfaceConnection()
dbif.connect()
samples = []
first_strds = tgis.open_old_stds(strds_names[0], "strds", dbif)
# Single space time raster dataset
if len(strds_names) == 1:
granu = first_strds.get_granularity()
rows = first_strds.get_registered_maps(
"name,mapset,start_time,end_time", tempwhere, "start_time", dbif)
if not rows:
dbif.close()
grass.fatal(
_("Space time raster dataset <%s> is empty") %
first_strds.get_id())
for row in rows:
start = row["start_time"]
end = row["end_time"]
raster_maps = [
row["name"] + "@" + row["mapset"],
]
s = Sample(start, end, raster_maps, first_strds.get_name(), granu)
samples.append(s)
else:
# Multiple space time raster datasets
for name in strds_names[1:]:
dataset = tgis.open_old_stds(name, "strds", dbif)
if dataset.get_temporal_type() != first_strds.get_temporal_type():
grass.fatal(
_(
"Temporal type of space time raster "
"datasets must be equal\n<%(a)s> of type "
"%(type_a)s do not match <%(b)s> of type "
"%(type_b)s" % {
"a": first_strds.get_id(),
"type_a": first_strds.get_temporal_type(),
"b": dataset.get_id(),
"type_b": dataset.get_temporal_type()
}))
mapmatrizes = tgis.sample_stds_by_stds_topology(
"strds", "strds", strds_names, strds_names[0], False, None,
"equal", False, False)
#TODO check granularity for multiple STRDS
for i in range(len(mapmatrizes[0])):
isvalid = True
mapname_list = []
for mapmatrix in mapmatrizes:
entry = mapmatrix[i]
if entry["samples"]:
sample = entry["samples"][0]
name = sample.get_id()
if name is None:
isvalid = False
break
else:
mapname_list.append(name)
if isvalid:
entry = mapmatrizes[0][i]
map = entry["granule"]
start, end = map.get_temporal_extent_as_tuple()
s = Sample(start, end, mapname_list, name)
samples.append(s)
# Get the layer and database connections of the input vector
if output:
gcopy(input, output, 'vector')
else:
output = input
msgr = Messenger()
perc_curr = 0
perc_tot = len(samples)
pymap = Vector(output)
try:
pymap.open('r')
except:
dbif.close()
grass.fatal(_("Unable to create vector map <%s>" % output))
if len(pymap.dblinks) == 0:
try:
pymap.close()
grass.run_command("v.db.addtable", map=output)
except CalledModuleError:
dbif.close()
grass.fatal(
_("Unable to add table <%s> to vector map <%s>" % output))
if pymap.is_open():
pymap.close()
for sample in samples:
raster_names = sample.raster_names
# Call v.what.rast for each raster map
for name in raster_names:
coltype = "DOUBLE PRECISION"
# Get raster map type
raster_map = tgis.RasterDataset(name)
raster_map.load()
if raster_map.metadata.get_datatype() == "CELL":
coltype = "INT"
day = sample.printDay()
column_name = "%s_%s" % (sample.strds_name, day)
column_string = "%s %s" % (column_name, coltype)
column_string.replace('.', '_')
try:
grass.run_command("v.db.addcolumn",
map=output,
column=column_string,
overwrite=overwrite)
except CalledModuleError:
dbif.close()
grass.fatal(
_("Unable to add column %s to vector map "
"<%s> ") % (column_string, output))
try:
grass.run_command("v.what.rast",
map=output,
raster=name,
column=column_name,
where=where,
quiet=quiet)
except CalledModuleError:
dbif.close()
grass.fatal(
_("Unable to run v.what.rast for vector map"
" <%s> and raster map <%s>") %
(output, str(raster_names)))
msgr.percent(perc_curr, perc_tot, 1)
perc_curr += 1
dbif.close()
def main(options, flags):
import model as modellib
from config import ModelConfig
try:
imagesDir = options['images_directory']
modelPath = options['model']
classes = options['classes'].split(',')
if options['band1']:
band1 = options['band1'].split(',')
band2 = options['band2'].split(',')
band3 = options['band3'].split(',')
else:
band1 = list()
band2 = list()
band3 = list()
outputType = options['output_type']
if options['images_format']:
extension = options['images_format']
if options['images_format'][0] != '.':
extension = '.{}'.format(extension)
else:
extension = ''
# a directory where masks and georeferencing will be saved in case of
# external images
masksDir = gscript.core.tempfile().rsplit(os.sep, 1)[0]
except KeyError:
# GRASS parses keys and values as bytes instead of strings
imagesDir = options[b'images_directory'].decode('utf-8')
modelPath = options[b'model'].decode('utf-8')
classes = options[b'classes'].decode('utf-8').split(',')
if options[b'band1'].decode('utf-8'):
band1 = options[b'band1'].decode('utf-8').split(',')
band2 = options[b'band2'].decode('utf-8').split(',')
band3 = options[b'band3'].decode('utf-8').split(',')
else:
band1 = list()
band2 = list()
band3 = list()
outputType = options[b'output_type'].decode('utf-8')
if options[b'images_format'].decode('utf-8'):
extension = options[b'images_format'].decode('utf-8')
if extension[0] != '.':
extension = '.{}'.format(extension)
else:
extension = ''
newFlags = dict()
for flag, value in flags.items():
newFlags.update({flag.decode('utf-8'): value})
flags = newFlags
# a directory where masks and georeferencing will be saved in case of
# external images
masksDir = gscript.core.tempfile().decode('utf-8').rsplit(os.sep, 1)[0]
if len(band1) != len(band2) or len(band2) != len(band3):
gscript.fatal('Length of band1, band2 and band3 must be equal.')
# TODO: (3 different brands in case of lot of classes?)
if len(classes) > 255:
gscript.fatal('Too many classes. Must be less than 256.')
if len(set(classes)) != len(classes):
gscript.fatal('Two or more classes have the same name.')
# used colour corresponds to class_id
classesColours = range(len(classes) + 1)
# Create model object in inference mode.
config = ModelConfig(numClasses=len(classes) + 1)
model = modellib.MaskRCNN(mode="inference",
model_dir=modelPath,
config=config)
model.load_weights(modelPath, by_name=True)
masks = list()
detectedClasses = list()
# TODO: Use the whole list instead of iteration
if len(band1) > 0:
gscript.message('Detecting features in raster maps...')
# using maps imported in GRASS
mapsCount = len(band1)
for i in range(mapsCount):
gscript.percent(i + 1, mapsCount, 1)
maskTitle = '{}_{}'.format(band1[i].split('.')[0], i)
# load map into 3-band np.array
gscript.run_command('g.region', raster=band1[i], quiet=True)
bands = np.stack((garray.array(band1[i]), garray.array(
band2[i]), garray.array(band3[i])), 2)
# Run detection
results = model.detect([bands], verbosity=gscript.verbosity())
# Save results
for r in results:
parse_instances(
bands,
r['rois'],
r['masks'],
r['class_ids'],
# ['BG'] + [i for i in classes],
# r['scores'],
outputDir=masksDir,
which=outputType,
title=maskTitle,
colours=classesColours,
mList=masks,
cList=detectedClasses,
grassMap=True)
if imagesDir:
gscript.message('Detecting features in images from the directory...')
for imageFile in [
file for file in next(os.walk(imagesDir))[2]
if os.path.splitext(file)[1] == extension
]:
image = skimage.io.imread(os.path.join(imagesDir, imageFile))
if image.shape[2] > 3:
image = image[:, :, 0:3]
source = gdal.Open(os.path.join(imagesDir, imageFile))
sourceProj = source.GetProjection()
sourceTrans = source.GetGeoTransform()
# Run detection
results = model.detect([image], verbosity=gscript.verbosity())
# Save results
for r in results:
parse_instances(
image,
r['rois'],
r['masks'],
r['class_ids'],
# ['BG'] + [i for i in classes],
# r['scores'],
outputDir=masksDir,
which=outputType,
title=imageFile,
colours=classesColours,
proj=sourceProj,
trans=sourceTrans,
mList=masks,
cList=detectedClasses,
externalReferencing=flags['e'])
if flags['e']:
gscript.message('Masks detected. Georeferencing masks...')
external_georeferencing(imagesDir, classes, masksDir, masks,
detectedClasses, extension)
gscript.message('Converting masks to vectors...')
masksString = ','.join(masks)
for parsedClass in detectedClasses:
gscript.message('Processing {} map...'.format(classes[parsedClass -
1]))
i = 0
for maskName in masks:
gscript.percent(i, len(masks), 1)
gscript.run_command('g.region', raster=maskName, quiet=True)
gscript.run_command('r.mask',
raster=maskName,
maskcats=classesColours[parsedClass],
quiet=True)
gscript.run_command('r.to.vect',
's',
input=maskName,
output=maskName,
type=outputType,
quiet=True)
gscript.run_command('r.mask', 'r', quiet=True)
i += 1
gscript.run_command('v.patch',
input=masksString,
output=classes[parsedClass - 1])
gscript.run_command('g.remove',
'f',
name=masksString,
type='vector',
quiet=True)
gscript.run_command('g.remove',
'f',
name=masksString,
type='raster',
quiet=True)
def main(options, flags):
# Lazy import GDAL python bindings
try:
from osgeo import gdal, osr
except ImportError as e:
gscript.fatal(_("Module requires GDAL python bindings: {}").format(e))
import model as modellib
from config import ModelConfig
try:
imagesDir = options["images_directory"]
modelPath = options["model"]
classes = options["classes"].split(",")
if options["band1"]:
band1 = options["band1"].split(",")
band2 = options["band2"].split(",")
band3 = options["band3"].split(",")
else:
band1 = list()
band2 = list()
band3 = list()
outputType = options["output_type"]
if options["images_format"]:
extension = options["images_format"]
if options["images_format"][0] != ".":
extension = ".{}".format(extension)
else:
extension = ""
# a directory where masks and georeferencing will be saved in case of
# external images
masksDir = gscript.core.tempfile().rsplit(os.sep, 1)[0]
except KeyError:
# GRASS parses keys and values as bytes instead of strings
imagesDir = options[b"images_directory"].decode("utf-8")
modelPath = options[b"model"].decode("utf-8")
classes = options[b"classes"].decode("utf-8").split(",")
if options[b"band1"].decode("utf-8"):
band1 = options[b"band1"].decode("utf-8").split(",")
band2 = options[b"band2"].decode("utf-8").split(",")
band3 = options[b"band3"].decode("utf-8").split(",")
else:
band1 = list()
band2 = list()
band3 = list()
outputType = options[b"output_type"].decode("utf-8")
if options[b"images_format"].decode("utf-8"):
extension = options[b"images_format"].decode("utf-8")
if extension[0] != ".":
extension = ".{}".format(extension)
else:
extension = ""
newFlags = dict()
for flag, value in flags.items():
newFlags.update({flag.decode("utf-8"): value})
flags = newFlags
# a directory where masks and georeferencing will be saved in case of
# external images
masksDir = gscript.core.tempfile().decode("utf-8").rsplit(os.sep, 1)[0]
if len(band1) != len(band2) or len(band2) != len(band3):
gscript.fatal("Length of band1, band2 and band3 must be equal.")
# TODO: (3 different brands in case of lot of classes?)
if len(classes) > 255:
gscript.fatal("Too many classes. Must be less than 256.")
if len(set(classes)) != len(classes):
gscript.fatal("Two or more classes have the same name.")
# used colour corresponds to class_id
classesColours = range(len(classes) + 1)
# Create model object in inference mode.
config = ModelConfig(numClasses=len(classes) + 1)
model = modellib.MaskRCNN(mode="inference",
model_dir=modelPath,
config=config)
model.load_weights(modelPath, by_name=True)
masks = list()
detectedClasses = list()
# TODO: Use the whole list instead of iteration
if len(band1) > 0:
gscript.message("Detecting features in raster maps...")
# using maps imported in GRASS
mapsCount = len(band1)
for i in range(mapsCount):
gscript.percent(i + 1, mapsCount, 1)
maskTitle = "{}_{}".format(band1[i].split(".")[0], i)
# load map into 3-band np.array
gscript.run_command("g.region", raster=band1[i], quiet=True)
bands = np.stack(
(
garray.array(band1[i]),
garray.array(band2[i]),
garray.array(band3[i]),
),
2,
)
# Run detection
results = model.detect([bands], verbosity=gscript.verbosity())
# Save results
for r in results:
parse_instances(
bands,
r["rois"],
r["masks"],
r["class_ids"],
# ['BG'] + [i for i in classes],
# r['scores'],
outputDir=masksDir,
which=outputType,
title=maskTitle,
colours=classesColours,
mList=masks,
cList=detectedClasses,
grassMap=True,
)
if imagesDir:
gscript.message("Detecting features in images from the directory...")
for imageFile in [
file for file in next(os.walk(imagesDir))[2]
if os.path.splitext(file)[1] == extension
]:
image = skimage.io.imread(os.path.join(imagesDir, imageFile))
if image.shape[2] > 3:
image = image[:, :, 0:3]
source = gdal.Open(os.path.join(imagesDir, imageFile))
sourceProj = source.GetProjection()
sourceTrans = source.GetGeoTransform()
# Run detection
results = model.detect([image], verbosity=gscript.verbosity())
# Save results
for r in results:
parse_instances(
image,
r["rois"],
r["masks"],
r["class_ids"],
# ['BG'] + [i for i in classes],
# r['scores'],
outputDir=masksDir,
which=outputType,
title=imageFile,
colours=classesColours,
proj=sourceProj,
trans=sourceTrans,
mList=masks,
cList=detectedClasses,
externalReferencing=flags["e"],
)
if flags["e"]:
gscript.message("Masks detected. Georeferencing masks...")
external_georeferencing(imagesDir, classes, masksDir, masks,
detectedClasses, extension)
gscript.message("Converting masks to vectors...")
masksString = ",".join(masks)
for parsedClass in detectedClasses:
gscript.message("Processing {} map...".format(classes[parsedClass -
1]))
i = 0
for maskName in masks:
gscript.percent(i, len(masks), 1)
gscript.run_command("g.region", raster=maskName, quiet=True)
gscript.run_command(
"r.mask",
raster=maskName,
maskcats=classesColours[parsedClass],
quiet=True,
)
gscript.run_command(
"r.to.vect",
"s",
input=maskName,
output=maskName,
type=outputType,
quiet=True,
)
gscript.run_command("r.mask", "r", quiet=True)
i += 1
gscript.run_command("v.patch",
input=masksString,
output=classes[parsedClass - 1])
gscript.run_command("g.remove",
"f",
name=masksString,
type="vector",
quiet=True)
gscript.run_command("g.remove",
"f",
name=masksString,
type="raster",
quiet=True)
def main():
vector = options['map']
table = options['table']
layer = options['layer']
columns = options['columns']
key = options['key']
# does map exist in CURRENT mapset?
mapset = grass.gisenv()['MAPSET']
if not grass.find_file(vector, element = 'vector', mapset = mapset)['file']:
grass.fatal(_("Vector map <%s> not found in current mapset") % vector)
map_name = vector.split('@')[0]
if not table:
if layer == '1':
grass.verbose(_("Using vector map name as table name: <%s>") % map_name)
table = map_name
else:
# to avoid tables with identical names on higher layers
table = "%s_%s" % (map_name, layer)
grass.verbose(_("Using vector map name extended by layer number as table name: <%s>") % table)
else:
grass.verbose(_("Using user specified table name: %s") % table)
# check if DB parameters are set, and if not set them.
grass.run_command('db.connect', flags = 'c')
grass.verbose(_("Creating new DB connection based on default mapset settings..."))
kv = grass.db_connection()
database = kv['database']
driver = kv['driver']
schema = kv['schema']
# maybe there is already a table linked to the selected layer?
nuldev = file(os.devnull, 'w')
try:
grass.vector_db(map_name, stderr = nuldev)[int(layer)]
grass.fatal(_("There is already a table linked to layer <%s>") % layer)
except KeyError:
pass
# maybe there is already a table with that name?
tables = grass.read_command('db.tables', flags = 'p', database = database, driver = driver,
stderr = nuldev)
if not table in tables.splitlines():
if columns:
column_def = map(lambda x: x.strip().lower(), columns.strip().split(','))
else:
column_def = []
# if not existing, create it:
column_def_key = "%s integer" % key
if column_def_key not in column_def:
column_def.insert(0, column_def_key)
column_def = ','.join(column_def)
grass.verbose(_("Creating table with columns (%s)...") % column_def)
sql = "CREATE TABLE %s (%s)" % (table, column_def)
try:
grass.run_command('db.execute',
database=database, driver=driver, sql=sql)
except CalledModuleError:
grass.fatal(_("Unable to create table <%s>") % table)
# connect the map to the DB:
if schema:
table = '{schema}.{table}'.format(schema=schema, table=table)
grass.run_command('v.db.connect', quiet = True,
map = map_name, database = database, driver = driver,
layer = layer, table = table, key = key)
# finally we have to add cats into the attribute DB to make modules such as v.what.rast happy:
# (creates new row for each vector line):
grass.run_command('v.to.db', map = map_name, layer = layer,
option = 'cat', column = key, qlayer = layer)
grass.verbose(_("Current attribute table links:"))
if grass.verbosity() > 2:
grass.run_command('v.db.connect', flags = 'p', map = map_name)
# write cmd history:
grass.vector_history(map_name)
return 0
def main():
# Get the options
type = options["type"]
temporal_type = options["temporaltype"]
columns = options["columns"]
order = options["order"]
where = options["where"]
separator = gscript.separator(options["separator"])
outpath = options["output"]
colhead = flags['c']
# Make sure the temporal database exists
tgis.init()
sp = tgis.dataset_factory(type, None)
dbif = tgis.SQLDatabaseInterfaceConnection()
dbif.connect()
first = True
if gscript.verbosity() > 0 and not outpath:
sys.stderr.write("----------------------------------------------\n")
for ttype in temporal_type.split(","):
if ttype == "absolute":
time = "absolute time"
else:
time = "relative time"
stds_list = tgis.get_dataset_list(type, ttype, columns, where, order, dbif=dbif)
# Use the correct order of the mapsets, hence first the current mapset, then
# alphabetic ordering
mapsets = tgis.get_tgis_c_library_interface().available_mapsets()
if outpath:
outfile = open(outpath, 'w')
# Print for each mapset separately
for key in mapsets:
if key in stds_list.keys():
rows = stds_list[key]
if rows:
if gscript.verbosity() > 0 and not outpath:
if issubclass(sp.__class__, tgis.AbstractMapDataset):
sys.stderr.write(_("Time stamped %s maps with %s available in mapset <%s>:\n")%\
(sp.get_type(), time, key))
else:
sys.stderr.write(_("Space time %s datasets with %s available in mapset <%s>:\n")%\
(sp.get_new_map_instance(None).get_type(), time, key))
# Print the column names if requested
if colhead == True and first == True:
output = ""
count = 0
for key in rows[0].keys():
if count > 0:
output += separator + str(key)
else:
output += str(key)
count += 1
if outpath:
outfile.write("{st}\n".format(st=output))
else:
print output
first = False
for row in rows:
output = ""
count = 0
for col in row:
if count > 0:
output += separator + str(col)
else:
output += str(col)
count += 1
if outpath:
outfile.write("{st}\n".format(st=output))
else:
print output
if outpath:
outfile.close()
dbif.close()
def main():
# set the home path
grass_env_file = None # see check_shell()
if sys.platform == "win32":
grass_config_dirname = "GRASS7"
grass_config_dir = os.path.join(os.getenv("APPDATA"),
grass_config_dirname)
else:
grass_config_dirname = ".grass7"
grass_config_dir = os.path.join(os.getenv("HOME"),
grass_config_dirname)
# configuration directory
rlidir = os.path.join(grass_config_dir, "r.li")
# check if GISBASE is set
if "GISBASE" not in os.environ:
# return an error advice
grass.fatal(_("You must be in GRASS GIS to run this program."))
# input raster map
map_in = options["input"]
# output raster map
map_out = options["prefix"]
# resolution of moving windows
res = options["size"]
# alpha value for r.renyi
alpha = options["alpha"]
# method to use
methods = options["method"]
# excluded method
excludes = options["exclude"]
resolution = checkValues(res)
if alpha != "":
alpha_value = checkValues(alpha, True)
else:
alpha_value = ""
# check if ~/.r.li path exists
if not os.path.exists(rlidir):
# create ~/.grass7/r.li
os.mkdir(rlidir)
# set overwrite
overwrite = grass.overwrite()
quiet = True
if grass.verbosity() > 2:
quiet = False
# if method and exclude option are not null return an error
if methods != "simpson,shannon,pielou,renyi" and excludes != "":
grass.fatal(
_("You can either use 'method' or 'exclude' option but not both"))
# calculate not excluded index
elif excludes != "":
excludes = excludes.split(",")
checkAlpha(excludes, alpha_value, True)
calculateE(rlidir, map_in, map_out, resolution, alpha_value, excludes,
quiet, overwrite)
# calculate method
elif methods != "":
methods = methods.split(",")
checkAlpha(methods, alpha_value)
calculateM(rlidir, map_in, map_out, resolution, alpha_value, methods,
quiet, overwrite)
# remove configuration files
if not flags["t"]:
removeConfFile(resolution, rlidir)
grass.message(_("Done."))
'pfactor' : 'pfactor',
'kfactor' : 'kfactor'
}
}
#END OF USER SETTINGS
###DO NOT CHANGE ANYTHING AFTER THIS LINE !
import grass.script as gscript
from grass.pygrass.gis import Mapset
from grass.pygrass.gis.region import Region
from grass.pygrass.modules.shortcuts import raster as r, vector as v, general as g
from grass.pygrass.modules import Module
quiet = True
if gscript.verbosity() > 2:
quiet=False
## define own modules in pygrass
rsoillossbare = Module("r.soilloss.bare")
rsoillossupdate = Module("r.soilloss.update")
rsoillossgrow = Module("r.soilloss.grow")
rsoillosscpmax = Module("r.soilloss.cpmax")
rsoillossreclass = Module("r.soilloss.reclass")
rsoillossstats = Module("r.soilloss.stats")
vinogr = Module("v.in.ogr")
def main(options, flags):
config_name = options['configuration']
params = owsConnections[config_name]
