def bspline_param(vectormap, depvar):
"""Get output bspline parameter estimates"""
stfact = Module("v.surf.bspline",
flags="ec",
input=vectormap,
column=depvar,
memory=1024,
stdout_=PIPE).outputs.stdout
stepdist = float(stfact.split(':')[-1].strip())
stfact = Module("v.surf.bspline",
flags="c",
input=vectormap,
ew_step=stepdist,
ns_step=stepdist,
column=depvar,
memory=1024,
stdout_=PIPE).outputs.stdout
stfact = stfact.replace(" ", "")
stfact = stfact.split("\n")[1:-1]
stfact = [z.split("|") for z in stfact]
stfact = [[float(x) for x in y if x != ''] for y in stfact]
minlambda = min(stfact, key=lambda x: abs(x[1]))[0]
return (stepdist, minlambda)
def main(options, flags):
# Variables
raster_cat = options["raster"]
raster_cat = raster_cat.split(",")
raster_cat_names = [z.split("@")[0] for z in raster_cat]
raster_cat_names = [x.lower() for x in raster_cat_names]
raster_cont = options["raster2"]
raster_cont = raster_cont.split(",")
raster_cont_names = [z.split("@")[0] for z in raster_cont]
raster_cont_names = [x.lower() for x in raster_cont_names]
input_vector = options["vector"]
output_vector = options["output"]
if flags["o"]:
tmp_layer = tmpname()
Module("g.copy", vector=[input_vector, output_vector], quiet=True)
else:
tmp_layer = output_vector
# Create vector with column names
base_column_names = ["x double precision, y double precision, label integer"]
for i, raster_name in enumerate(raster_cat):
data_types = gs.parse_command("r.info", flags="g", map=raster_name, quiet=True)[
"datatype"
]
if data_types == "CELL":
base_column_names.append(
"{0}_ID integer, {0} varchar(255)".format(raster_cat_names[i])
)
else:
base_column_names.append(
"ID_{0} double precision, {0} varchar(255)".format(raster_cat_names[i])
)
column_names = ",".join(base_column_names)
# Get raster points of raster layers with labels
# Export point map to text file first and use that as input in r.what
point_to_ascii = Module(
"v.out.ascii",
input=input_vector,
format="point",
separator="space",
precision=12,
stdout_=PIPE,
).outputs.stdout
raster_cats = Module(
"r.what", flags="f", map=raster_cat, stdin_=point_to_ascii, stdout_=PIPE
).outputs.stdout
ascii_to_point = raster_cats.replace("|*|", "||").replace("\r", "")
Module(
"v.in.ascii",
input="-",
stdin_=ascii_to_point,
output=tmp_layer,
columns=column_names,
separator="pipe",
format="point",
x=1,
y=2,
quiet=True,
)
# In- or exclude coordinates
if not flags["c"]:
Module("v.db.dropcolumn", map=tmp_layer, columns=["x", "y"])
# Get raster points of raster layers without labels (optional)
if options["raster2"]:
for j, raster_cont_values in enumerate(raster_cont):
Module(
"v.what.rast",
map=tmp_layer,
raster=raster_cont_values,
column=raster_cont_names[j],
quiet=True,
)
# Join table of original layer (and drop label columns)
if flags["o"]:
cols = Module("db.columns", table=tmp_layer, stdout_=PIPE).outputs.stdout.split(
"\n"
)
cols.pop()
del cols[:1]
sqlstat = "CREATE INDEX {0}_label ON {0} (label);".format(tmp_layer)
Module("db.execute", sql=sqlstat)
Module(
"v.db.join",
map=output_vector,
column="cat",
other_table=tmp_layer,
other_column="label",
subset_columns=cols,
)
# Remove label column
Module("v.db.dropcolumn", map=output_vector, columns=["label"])
# Write metadata
gs.vector_history(output_vector, replace=True)
def main(options, flags):
gisbase = os.getenv('GISBASE')
if not gisbase:
gs.fatal(_('$GISBASE not defined'))
return 0
# Variables
RAST = options['raster']
RAST = RAST.split(',')
RASTL = [z.split('@')[0] for z in RAST]
RASTL = [x.lower() for x in RASTL]
RAST2 = options['raster2']
RAST2 = RAST2.split(',')
RASTL2 = [z.split('@')[0] for z in RAST2]
RASTL2 = [x.lower() for x in RASTL2]
VECT = options['vector']
OUTP = options['output']
# Create vector with column names
CT = ['x double precision, y double precision, label integer']
for i in xrange(len(RAST)):
DT = gs.parse_command('r.info', flags='g', map=RAST[i],
quiet=True)['datatype']
if DT == 'CELL':
CT.append("ID_{0} integer, {0} varchar(255)".format(RASTL[i]))
else:
CT.append("ID_{0} double precision, {0} varchar(255)".format(
RASTL[i]))
CNT = ','.join(CT)
# Get raster points of raster layers with labels
# Export point map to text file first and use that as input in r.what
# TODO: the above is workaround to get vector cat value as label. Easier,
# would be to use vector point map directly as input, but that does not
# give label to link back to old vector layer
PAT = Module('v.out.ascii',
input=VECT,
format='point',
separator='space',
precision=12,
stdout_=PIPE).outputs.stdout
CAT = Module('r.what', flags='f', map=RAST, stdin_=PAT,
stdout_=PIPE).outputs.stdout
CATV = CAT.replace('|*|', '||')
Module('v.in.ascii',
input='-',
stdin_=CATV,
output=OUTP,
columns=CNT,
separator='pipe',
format='point',
x=1,
y=2,
quiet=True)
# Get raster points of raster layers without labels (optional)
if options['raster2']:
for j in xrange(len(RAST2)):
DT = gs.parse_command('r.info',
flags='g',
map=RAST2[j],
quiet=True)['datatype']
if DT == 'CELL':
CT = "{} integer".format(RASTL2[j])
else:
CT = "{} double precision".format(RASTL2[j])
Module('v.db.addcolumn', map=OUTP, columns=CT)
Module('v.what.rast', map=OUTP, raster=RAST2[j], column=RASTL2[j])
# Write metadata
opt2 = dict((k, v) for k, v in options.iteritems() if v)
hist = ' '.join("{!s}={!r}".format(k, v) for (k, v) in opt2.iteritems())
hist = "v.what.rastlabel {}".format(hist)
Module('v.support',
map=OUTP,
comment="created with v.what.rastlabel",
cmdhist=hist,
flags='r',
quiet=True)
def main(options, flags):
gisbase = os.getenv("GISBASE")
if not gisbase:
gs.fatal(_("$GISBASE not defined"))
return 0
# Reference / sample area or points
ref_rast = options["ref_rast"]
ref_vect = options["ref_vect"]
if ref_rast:
reftype = gs.raster_info(ref_rast)
if reftype["datatype"] != "CELL":
gs.fatal(_("The ref_rast map must have type CELL (integer)"))
if (reftype["min"] != 0 and reftype["min"] != 1) or reftype["max"] != 1:
gs.fatal(
_(
"The ref_rast map must be a binary raster,"
" i.e. it should contain only values 0 and 1 or 1 only"
" (now the minimum is {} and maximum is {})".format(
reftype["min"], reftype["max"]
)
)
)
# old environmental layers & variable names
reference_layer = options["env"]
reference_layer = reference_layer.split(",")
raster_exists(reference_layer)
variable_name = [z.split("@")[0] for z in reference_layer]
variable_name = [x.lower() for x in variable_name]
# new environmental variables
projection_layers = options["env_proj"]
if not projection_layers:
to_be_projected = False
projection_layers = reference_layer
else:
to_be_projected = True
projection_layers = projection_layers.split(",")
raster_exists(projection_layers)
if (
len(projection_layers) != len(reference_layer)
and len(projection_layers) != 0
):
gs.fatal(
_(
"The number of reference and predictor variables"
" should be the same. You provided {} reference and {}"
" projection variables".format(
len(reference_layer), len(projection_layers)
)
)
)
# output layers
opl = options["output"]
opc = opl + "_MES"
ipi = [opl + "_" + i for i in variable_name]
# flags
flm = flags["m"]
flk = flags["k"]
fln = flags["n"]
fli = flags["i"]
flc = flags["c"]
# digits / precision
digits = int(options["digits"])
digits2 = pow(10, digits)
# get current region settings, to compare to new ones later
region_1 = gs.parse_command("g.region", flags="g")
# Text for history in metadata
opt2 = dict((k, v) for k, v in options.items() if v)
hist = " ".join("{!s}={!r}".format(k, v) for (k, v) in opt2.items())
hist = "r.mess {}".format(hist)
unused, tmphist = tempfile.mkstemp()
with open(tmphist, "w") as text_file:
text_file.write(hist)
# Create reference layer if not defined
if not ref_rast and not ref_vect:
ref_rast = tmpname("tmp0")
Module(
"r.mapcalc",
"{0} = if(isnull({1}),null(),1)".format(ref_rast, reference_layer[0]),
quiet=True,
)
# Create the recode table - Reference distribution is raster
citiam = gs.find_file(name="MASK", element="cell", mapset=gs.gisenv()["MAPSET"])
if citiam["fullname"]:
rname = tmpname("tmp3")
Module("r.mapcalc", expression="{} = MASK".format(rname), quiet=True)
if ref_rast:
vtl = ref_rast
# Create temporary layer based on reference layer
tmpf0 = tmpname("tmp2")
Module(
"r.mapcalc", expression="{0} = int({1} * 1)".format(tmpf0, vtl), quiet=True
)
Module("r.null", map=tmpf0, setnull=0, quiet=True)
if citiam["fullname"]:
Module("r.mask", flags="r", quiet=True)
for i in range(len(reference_layer)):
# Create mask based on combined MASK/reference layer
Module("r.mask", raster=tmpf0, quiet=True)
# Calculate the frequency distribution
tmpf1 = tmpname("tmp4")
Module(
"r.mapcalc",
expression="{0} = int({1} * {2})".format(
tmpf1, digits2, reference_layer[i]
),
quiet=True,
)
stats_out = Module(
"r.stats",
flags="cn",
input=tmpf1,
sort="asc",
separator=";",
stdout_=PIPE,
).outputs.stdout
stval = {}
stats_outlines = stats_out.replace("\r", "").split("\n")
stats_outlines = [_f for _f in stats_outlines if _f]
for z in stats_outlines:
[val, count] = z.split(";")
stval[float(val)] = float(count)
sstval = sorted(stval.items(), key=operator.itemgetter(0))
sstval = np.matrix(sstval)
a = np.cumsum(np.array(sstval), axis=0)
b = np.sum(np.array(sstval), axis=0)
c = a[:, 1] / b[1] * 100
# Remove tmp mask and set region to env_proj if needed
Module("r.mask", quiet=True, flags="r")
if to_be_projected:
gs.use_temp_region()
Module("g.region", quiet=True, raster=projection_layers[0])
# get new region settings, to compare to original ones later
region_2 = gs.parse_command("g.region", flags="g")
# Get min and max values for recode table (based on full map)
tmpf2 = tmpname("tmp5")
Module(
"r.mapcalc",
expression="{0} = int({1} * {2})".format(
tmpf2, digits2, projection_layers[i]
),
quiet=True,
)
d = gs.parse_command("r.univar", flags="g", map=tmpf2, quiet=True)
# Create recode rules
Dmin = int(d["min"])
Dmax = int(d["max"])
envmin = np.min(np.array(sstval), axis=0)[0]
envmax = np.max(np.array(sstval), axis=0)[0]
if Dmin < envmin:
e1 = Dmin - 1
else:
e1 = envmin - 1
if Dmax > envmax:
e2 = Dmax + 1
else:
e2 = envmax + 1
a1 = np.hstack([(e1), np.array(sstval.T[0])[0, :]])
a2 = np.hstack([np.array(sstval.T[0])[0, :] - 1, (e2)])
b1 = np.hstack([(0), c])
fd2, tmprule = tempfile.mkstemp(suffix=variable_name[i])
with open(tmprule, "w") as text_file:
for k in np.arange(0, len(b1.T)):
text_file.write(
"%s:%s:%s\n" % (str(int(a1[k])), str(int(a2[k])), str(b1[k]))
)
# Create the recode layer and calculate the IES
compute_ies(tmprule, ipi[i], tmpf2, envmin, envmax)
Module(
"r.support",
map=ipi[i],
title="IES {}".format(reference_layer[i]),
units="0-100 (relative score)",
description="Environmental similarity {}".format(reference_layer[i]),
loadhistory=tmphist,
)
# Clean up
os.close(fd2)
os.remove(tmprule)
# Change region back to original
gs.del_temp_region()
# Create the recode table - Reference distribution is vector
else:
vtl = ref_vect
# Copy point layer and add columns for variables
tmpf0 = tmpname("tmp7")
Module(
"v.extract", quiet=True, flags="t", input=vtl, type="point", output=tmpf0
)
Module("v.db.addtable", quiet=True, map=tmpf0)
# TODO: see if there is a more efficient way to handle the mask
if citiam["fullname"]:
Module("r.mask", quiet=True, flags="r")
# Upload raster values and get value in python as frequency table
sql1 = "SELECT cat FROM {}".format(str(tmpf0))
cn = len(np.hstack(db.db_select(sql=sql1)))
for m in range(len(reference_layer)):
# Set mask back (this means that points outside the mask will
# be ignored in the computation of the frequency distribution
# of the reference variabele env(m))
if citiam["fullname"]:
Module("g.copy", raster=[rname, "MASK"], quiet=True)
# Compute frequency distribution of variable(m)
mid = str(m)
laytype = gs.raster_info(reference_layer[m])["datatype"]
if laytype == "CELL":
columns = "envvar_{} integer".format(str(mid))
else:
columns = "envvar_{} double precision".format(str(mid))
Module("v.db.addcolumn", map=tmpf0, columns=columns, quiet=True)
sql2 = "UPDATE {} SET envvar_{} = NULL".format(str(tmpf0), str(mid))
Module("db.execute", sql=sql2, quiet=True)
coln = "envvar_{}".format(str(mid))
Module(
"v.what.rast",
quiet=True,
map=tmpf0,
layer=1,
raster=reference_layer[m],
column=coln,
)
sql3 = (
"SELECT {0}, count({0}) from {1} WHERE {0} IS NOT NULL "
"GROUP BY {0} ORDER BY {0}"
).format(coln, tmpf0)
volval = np.vstack(db.db_select(sql=sql3))
volval = volval.astype(np.float, copy=False)
a = np.cumsum(volval[:, 1], axis=0)
b = np.sum(volval[:, 1], axis=0)
c = a / b * 100
# Check for point without values
if b < cn:
gs.info(
_(
"Please note that there were {} points without "
"value. This is probably because they are outside "
"the computational region or mask".format((cn - b))
)
)
# Set region to env_proj layers (if different from env) and remove
# mask (if set above)
if citiam["fullname"]:
Module("r.mask", quiet=True, flags="r")
if to_be_projected:
gs.use_temp_region()
Module("g.region", quiet=True, raster=projection_layers[0])
region_2 = gs.parse_command("g.region", flags="g")
# Multiply env_proj layer with dignum
tmpf2 = tmpname("tmp8")
Module(
"r.mapcalc",
expression="{0} = int({1} * {2})".format(
tmpf2, digits2, projection_layers[m]
),
quiet=True,
)
# Calculate min and max values of sample points and raster layer
envmin = int(min(volval[:, 0]) * digits2)
envmax = int(max(volval[:, 0]) * digits2)
Drange = gs.read_command("r.info", flags="r", map=tmpf2)
Drange = str.splitlines(Drange)
Drange = np.hstack([i.split("=") for i in Drange])
Dmin = int(Drange[1])
Dmax = int(Drange[3])
if Dmin < envmin:
e1 = Dmin - 1
else:
e1 = envmin - 1
if Dmax > envmax:
e2 = Dmax + 1
else:
e2 = envmax + 1
a0 = volval[:, 0] * digits2
a0 = a0.astype(np.int, copy=False)
a1 = np.hstack([(e1), a0])
a2 = np.hstack([a0 - 1, (e2)])
b1 = np.hstack([(0), c])
fd3, tmprule = tempfile.mkstemp(suffix=variable_name[m])
with open(tmprule, "w") as text_file:
for k in np.arange(0, len(b1)):
rtmp = "{}:{}:{}\n".format(
str(int(a1[k])), str(int(a2[k])), str(b1[k])
)
text_file.write(rtmp)
# Create the recode layer and calculate the IES
compute_ies(tmprule, ipi[m], tmpf2, envmin, envmax)
Module(
"r.support",
map=ipi[m],
title="IES {}".format(reference_layer[m]),
units="0-100 (relative score)",
description="Environmental similarity {}".format(reference_layer[m]),
loadhistory=tmphist,
)
# Clean up
os.close(fd3)
os.remove(tmprule)
# Change region back to original
gs.del_temp_region()
# Calculate MESS statistics
# Set region to env_proj layers (if different from env)
# Note: this changes the region, to ensure the newly created layers
# are actually visible to the user. This goes against normal practise
# There will be a warning.
if to_be_projected:
Module("g.region", quiet=True, raster=projection_layers[0])
# MES
Module("r.series", quiet=True, output=opc, input=ipi, method="minimum")
gs.write_command("r.colors", map=opc, rules="-", stdin=COLORS_MES, quiet=True)
# Write layer metadata
Module(
"r.support",
map=opc,
title="Areas with novel conditions",
units="0-100 (relative score)",
description="The multivariate environmental similarity" "(MES)",
loadhistory=tmphist,
)
# Area with negative MES
if fln:
mod1 = "{}_novel".format(opl)
Module("r.mapcalc", "{} = int(if( {} < 0, 1, 0))".format(mod1, opc), quiet=True)
# Write category labels
Module("r.category", map=mod1, rules="-", stdin=RECL_MESNEG, quiet=True)
# Write layer metadata
Module(
"r.support",
map=mod1,
title="Areas with novel conditions",
units="-",
source1="Based on {}".format(opc),
description="1 = novel conditions, 0 = within range",
loadhistory=tmphist,
)
# Most dissimilar variable (MoD)
if flm:
tmpf4 = tmpname("tmp9")
mod2 = "{}_MoD".format(opl)
Module("r.series", quiet=True, output=tmpf4, input=ipi, method="min_raster")
Module("r.mapcalc", "{} = int({})".format(mod2, tmpf4), quiet=True)
fd4, tmpcat = tempfile.mkstemp()
with open(tmpcat, "w") as text_file:
for cats in range(len(ipi)):
text_file.write("{}:{}\n".format(str(cats), reference_layer[cats]))
Module("r.category", quiet=True, map=mod2, rules=tmpcat, separator=":")
os.close(fd4)
os.remove(tmpcat)
# Write layer metadata
Module(
"r.support",
map=mod2,
title="Most dissimilar variable (MoD)",
units="-",
source1="Based on {}".format(opc),
description="Name of most dissimilar variable",
loadhistory=tmphist,
)
# sum(IES), where IES < 0
if flk:
mod3 = "{}_SumNeg".format(opl)
c0 = -0.01 / digits2
Module(
"r.series",
quiet=True,
input=ipi,
method="sum",
range=("-inf", c0),
output=mod3,
)
gs.write_command("r.colors", map=mod3, rules="-", stdin=COLORS_MES, quiet=True)
# Write layer metadata
Module(
"r.support",
map=mod3,
title="Sum of negative IES values",
units="-",
source1="Based on {}".format(opc),
description="Sum of negative IES values",
loadhistory=tmphist,
)
# Number of layers with negative values
if flc:
tmpf5 = tmpname("tmp10")
mod4 = "{}_CountNeg".format(opl)
MinMes = gs.read_command("r.info", quiet=True, flags="r", map=opc)
MinMes = str.splitlines(MinMes)
MinMes = float(np.hstack([i.split("=") for i in MinMes])[1])
c0 = -0.0001 / digits2
Module(
"r.series",
quiet=True,
input=ipi,
output=tmpf5,
method="count",
range=(MinMes, c0),
)
gs.mapcalc("$mod4 = int($tmpf5)", mod4=mod4, tmpf5=tmpf5, quiet=True)
# Write layer metadata
Module(
"r.support",
map=mod4,
title="Number of layers with negative values",
units="-",
source1="Based on {}".format(opc),
description="Number of layers with negative values",
loadhistory=tmphist,
)
# Remove IES layers
if fli:
Module("g.remove", quiet=True, flags="f", type="raster", name=ipi)
# Clean up tmp file
# os.remove(tmphist)
gs.message(_("Finished ...\n"))
if region_1 != region_2:
gs.message(
_(
"\nPlease note that the region has been changes to match"
" the set of projection (env_proj) variables.\n"
)
)
def main(options, flags):
# Check if running in GRASS
gisbase = os.getenv("GISBASE")
if not gisbase:
gs.fatal(_("$GISBASE not defined"))
return 0
# variables
ipl = options["env"]
ipl = ipl.split(",")
raster_exists(ipl)
ipn = [z.split("@")[0] for z in ipl]
ipn = [x.lower() for x in ipn]
out = options["output"]
if out:
tmpf0 = out
else:
tmpf0 = tmpname("reb0")
filename = options["file"]
ref = options["ref"]
flag_m = flags["m"]
flag_n = flags["n"]
flag_o = flags["o"]
flag_i = flags["i"]
digits = int(options["digits"])
digits2 = pow(10, digits)
# Check if ref map is of type cell and values are limited to 1 and 0
reftype = gs.raster_info(ref)
if reftype["datatype"] != "CELL":
gs.fatal(_("Your reference map must have type CELL (integer)"))
if reftype["min"] != 0 or reftype["max"] != 1:
gs.fatal(
_("The input raster map must be a binary raster,"
" i.e. it should contain only values 0 and 1 "
" (now the minimum is %d and maximum is %d)") %
(reftype["min"], reftype["max"]))
# Text for history in metadata
opt2 = dict((k, v) for k, v in options.items() if v)
hist = " ".join("{!s}={!r}".format(k, v) for (k, v) in opt2.items())
hist = "r.meb {}".format(hist)
unused, tmphist = tempfile.mkstemp()
text_file = open(tmphist, "w")
text_file.write(hist)
text_file.close()
# ------------------------------------------------------------------------
# Compute MES
# ------------------------------------------------------------------------
# Create temporary copy of ref layer
tmpref0 = tmpname("reb1")
CLEAN_RAST.append(tmpref0)
gs.run_command("g.copy", quiet=True, raster=(ref, tmpref0))
ipi = []
for j in range(len(ipl)):
# Calculate the frequency distribution
tmpf1 = tmpname("reb1")
CLEAN_RAST.append(tmpf1)
laytype = gs.raster_info(ipl[j])["datatype"]
if laytype == "CELL":
gs.run_command("g.copy", quiet=True, raster=(ipl[j], tmpf1))
else:
gs.mapcalc(
"$tmpf1 = int($dignum * $inplay)",
tmpf1=tmpf1,
inplay=ipl[j],
dignum=digits2,
quiet=True,
)
stats_out = Module(
"r.stats",
flags="cn",
input=tmpf1,
sort="asc",
separator=";",
stdout_=PIPE,
).outputs.stdout
stval = {}
stats_outlines = stats_out.replace("\r", "").split("\n")
stats_outlines = [_f for _f in stats_outlines if _f]
for z in stats_outlines:
[val, count] = z.split(";")
stval[float(val)] = float(count)
sstval = sorted(stval.items(), key=operator.itemgetter(0))
sstval = np.matrix(sstval)
a = np.cumsum(np.array(sstval), axis=0)
b = np.sum(np.array(sstval), axis=0)
c = a[:, 1] / b[1] * 100
# Create recode rules
e1 = np.min(np.array(sstval), axis=0)[0] - 99999
e2 = np.max(np.array(sstval), axis=0)[0] + 99999
a1 = np.hstack([(e1), np.array(sstval.T[0])[0, :]])
a2 = np.hstack([np.array(sstval.T[0])[0, :] - 1, (e2)])
b1 = np.hstack([(0), c])
fd2, tmprule = tempfile.mkstemp()
text_file = open(tmprule, "w")
for k in np.arange(0, len(b1.T)):
text_file.write("{}:{}:{}\n".format(int(a1[k]), int(a2[k]), b1[k]))
text_file.close()
# Create the recode layer and calculate the IES
tmpf2 = tmpname("reb2")
CLEAN_RAST.append(tmpf2)
gs.run_command("r.recode", input=tmpf1, output=tmpf2, rules=tmprule)
tmpf3 = tmpname("reb3")
CLEAN_RAST.append(tmpf3)
calcc = ("{1} = if({0} <= 50, 2 * float({0}), if({0} < 100, "
"2 * (100 - float({0}))))".format(tmpf2, tmpf3))
gs.mapcalc(calcc, quiet=True)
gs.run_command("g.remove",
quiet=True,
flags="f",
type="raster",
name=(tmpf2, tmpf1))
os.close(fd2)
ipi.append(tmpf3)
# ----------------------------------------------------------------------
# Calculate EB statistics
# ----------------------------------------------------------------------
# EB MES
if flag_m:
gs.info(_("\nThe EB based on mean ES values:\n"))
nmn = "{}_MES_mean".format(tmpf0)
gs.run_command("r.series",
quiet=True,
output=nmn,
input=tuple(ipi),
method="average")
gs.write_command("r.colors",
map=nmn,
rules="-",
stdin=COLORS_MES,
quiet=True)
ebm = EB(simlay=nmn, reflay=tmpref0)
if not out:
# Add to list of layers to be removed at completion
CLEAN_RAST.append(nmn)
else:
# Write layer metadata
gs.run_command(
"r.support",
map=nmn,
title="Multivariate environmental similarity (MES)",
units="0-100 (relative score",
description="MES (compuated as the average of "
"the individual similarity layers",
loadhistory=tmphist,
)
if flag_n:
gs.info(_("\nThe EB based on median ES values:\n"))
nmn = "{}_MES_median".format(tmpf0)
gs.run_command("r.series",
quiet=True,
output=nmn,
input=tuple(ipi),
method="median")
gs.write_command("r.colors",
map=nmn,
rules="-",
stdin=COLORS_MES,
quiet=True)
ebn = EB(simlay=nmn, reflay=tmpref0)
if not out:
CLEAN_RAST.append(nmn)
else:
# Write layer metadata
gs.run_command(
"r.support",
map=nmn,
title="Multivariate environmental similarity (MES)",
units="0-100 (relative score",
description="MES (compuated as the median of "
"the individual similarity layers",
loadhistory=tmphist,
)
if flag_o:
gs.info(_("\nThe EB based on minimum ES values:\n"))
nmn = "{}_MES_minimum".format(tmpf0)
gs.run_command("r.series",
quiet=True,
output=nmn,
input=tuple(ipi),
method="minimum")
gs.write_command("r.colors",
map=nmn,
rules="-",
stdin=COLORS_MES,
quiet=True)
ebo = EB(simlay=nmn, reflay=tmpref0)
if not out:
CLEAN_RAST.append(nmn)
else:
# Write layer metadata
gs.run_command(
"r.support",
map=nmn,
title="Multivariate environmental similarity (MES)",
units="0-100 (relative score",
description="MES (compuated as the minimum of "
"the individual similarity layers",
loadhistory=tmphist,
)
# EB individual layers
if flag_i:
ebi = {}
for mm in range(len(ipi)):
nmn = "{}_{}".format(tmpf0, ipn[mm])
if not out:
CLEAN_RAST.append(nmn)
gs.run_command("g.rename", quiet=True, raster=(ipi[mm], nmn))
gs.write_command("r.colors",
map=nmn,
rules="-",
stdin=COLORS_MES,
quiet=True)
gs.info(_("\nThe EB for {}:\n").format(ipn[mm]))
value = EB(simlay=nmn, reflay=tmpref0)
ebi[ipn[mm]] = value
gs.run_command(
"r.support",
map=nmn,
title="Environmental similarity (ES) for "
"{}".format(ipn[mm]),
units="0-100 (relative score",
description="Environmental similarity (ES) for "
"{}".format(ipn[mm]),
loadhistory=tmphist,
)
else:
gs.run_command("g.remove",
quiet=True,
flags="f",
type="raster",
name=ipi)
if filename:
with open(filename, "wt") as csvfile:
fieldnames = [
"variable", "median_region", "median_reference", "mad", "eb"
]
writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
writer.writeheader()
if flag_m:
writer.writerow({
"variable": "MES_mean",
"median_region": ebm[1],
"median_reference": ebm[2],
"mad": ebm[0],
"eb": ebm[3],
})
if flag_n:
writer.writerow({
"variable": "MES_median",
"median_region": ebn[1],
"median_reference": ebn[2],
"mad": ebn[0],
"eb": ebn[3],
})
if flag_o:
writer.writerow({
"variable": "MES_minimum",
"median_region": ebo[1],
"median_reference": ebo[2],
"mad": ebo[0],
"eb": ebo[3],
})
if flag_i:
mykeys = ebi.keys()
for vari in mykeys:
ebj = ebi[vari]
writer.writerow({
"variable": vari,
"median_region": ebj[1],
"median_reference": ebj[2],
"mad": ebj[0],
"eb": ebj[3],
})
gs.info(_("\nThe results are written to {}\n").format(filename))
gs.info("\n")
def bspline_validation(vector,
column,
lambda_i,
ew_step,
ns_step,
keep,
npartitions=4,
method='bilinear',
solver='cholesky',
maxit=10000,
memory=2048):
"""Compute validation statistics (rsme) for bspline extrapolation"""
# Temporary map
tmpmap = tmpname("cvbase_")
Module("g.copy", vector=[vector, tmpmap])
# Compute rsme over model with all callibration points
tmpout = tmpname("cvtmp4_")
Module("v.surf.bspline",
input=tmpmap,
column=column,
ew_step=ew_step,
ns_step=ns_step,
method=method,
lambda_i=lambda_i,
solver=solver,
maxit=maxit,
memory=memory,
raster_output=tmpout)
Module("v.what.rast", map=tmpmap, raster=tmpout, column="bspline")
stats = Module("db.select",
flags="c",
sql="SELECT {},bspline FROM {}".format(column, tmpmap),
stdout_=PIPE).outputs.stdout
stats = stats.replace("\n", "|")[:-1].split("|")
stats = (np.asarray([float(x) for x in stats],
dtype="float").reshape(len(stats) / 2, 2))
rsme_all = np.sqrt(np.mean(np.diff(stats, axis=1)**2))
if keep:
Module("g.rename", raster=[tmpout, keep])
else:
Module("g.remove", type="raster", name=tmpout, flags="f")
# Run n-fold crossvalidation
if npartitions > 0:
Module("v.kcv", map=tmpmap, npartitions=npartitions)
rsme = []
for i in range(1, npartitions + 1):
tmp_cal = tmpname("cvtmp_calibrate_")
tmp_val = tmpname("cvtmp_validate_")
tmpout1 = tmpname("cvtmp_output_1_")
tmpout2 = tmpname("cvtmp_output_2_")
tmpout3 = tmpname("cvtmp_output_3_")
Module("v.extract",
flags="r",
input=tmpmap,
output=tmp_cal,
where="part={}".format(i))
Module("v.extract",
input=tmpmap,
where="part={}".format(i),
output=tmp_val)
Module("v.surf.bspline",
input=tmp_cal,
column=column,
ew_step=ew_step,
ns_step=ns_step,
method=method,
lambda_i=lambda_i,
solver=solver,
maxit=maxit,
memory=memory,
output=tmpout1,
sparse_input=tmp_val)
Module("v.category",
input=tmpout1,
output=tmpout2,
option="del",
cat=-1)
Module("v.category", input=tmpout2, output=tmpout3, option="add")
Module("v.db.addtable", map=tmpout3)
Module("v.db.addcolumn",
map=tmpout3,
columns=("x double precision, y double precision, "
"z double precision"))
Module("v.to.db", map=tmpout3, option="coor", columns="x,y,z")
# TODO: need to find out how to use the from_ with Module
gs.run_command("v.distance",
from_=tmpout3,
to=tmp_val,
upload="to_attr",
column="x",
to_column=column)
stats = Module("db.select",
flags="c",
sql="SELECT x, z FROM {}".format(tmpout3),
stdout_=PIPE).outputs.stdout
stats = stats.replace("\n", "|")[:-1].split("|")
stats = (np.asarray([float(x) for x in stats],
dtype="float").reshape(len(stats) / 2, 2))
rsme.append(np.sqrt(np.mean(np.diff(stats, axis=1)**2)))
Module("g.remove", type="vector", pattern="cvtmp_*", flags="f")
Module("g.remove", type="vector", pattern="cvbase_*", flags="f")
return {
'rsme_full': rsme_all,
'rsme_cv_mean': np.asarray(rsme).mean(),
'rsme_cv_std': np.asarray(rsme).std(),
'rsme_cv': rsme
}
else:
return {'rsme_full': rsme_all}
def idw_validation(vector,
column,
keep,
npoints=12,
power=2,
npartitions=10,
memory=2048):
"""Compute validation statistics (rsme) for idw extrapolation"""
# Temporary map
tmpmap = tmpname("cvbase_")
Module("g.copy", vector=[vector, tmpmap])
# Compute rsme over model with all callibration points
tmpout = tmpname("cvtmp4_")
Module("v.surf.idw",
input=tmpmap,
column=column,
npoints=npoints,
power=power,
output=tmpout)
Module("v.what.rast", map=tmpmap, raster=tmpout, column="idw")
stats = Module("db.select",
flags="c",
sql="SELECT {},idw FROM {}".format(column, tmpmap),
stdout_=PIPE).outputs.stdout
stats = stats.replace("\n", "|")[:-1].split("|")
stats = (np.asarray([float(x) for x in stats],
dtype="float").reshape(len(stats) / 2, 2))
rsme_all = np.sqrt(np.mean(np.diff(stats, axis=1)**2))
if keep:
Module("g.rename", raster=[tmpout, keep])
else:
Module("g.remove", type="raster", name=tmpout, flags="f")
# Run n-fold crossvalidation
if npartitions > 0:
Module("v.kcv", map=tmpmap, npartitions=npartitions)
rsme = []
for i in range(1, npartitions + 1):
tmppnt = tmpname("cvtmp2_")
tmpspa = tmpname("cvtmp3_")
tmpout = tmpname("cvtmp4_")
Module("v.extract",
flags="r",
input=tmpmap,
output=tmppnt,
where="part={}".format(i))
Module("v.extract",
input=tmpmap,
where="part={}".format(i),
output=tmpspa)
Module("v.surf.idw",
input=tmppnt,
column=column,
npoints=npoints,
power=power,
output=tmpout)
Module("v.what.rast", map=tmpspa, raster=tmpout, column="idw")
stats = Module("db.select",
flags="c",
sql="SELECT {},idw FROM {}".format(column, tmpspa),
stdout_=PIPE).outputs.stdout
stats = stats.replace("\n", "|")[:-1].split("|")
stats = (np.asarray([float(x) for x in stats],
dtype="float").reshape(len(stats) / 2, 2))
rsme.append(np.sqrt(np.mean(np.diff(stats, axis=1)**2)))
Module("g.remove", type="all", pattern="cvtmp*", flags="f")
Module("g.remove", type="vector", pattern="cvbase_*", flags="f")
# Return output
return {
'rsme_full': rsme_all,
'rsme_cv_mean': np.asarray(rsme).mean(),
'rsme_cv_std': np.asarray(rsme).std(),
'rsme_cv': rsme
}
