def setUp(self):
"""Create input data
"""
self.runModule("g.region", res=1, n=90, s=0, w=0, e=90)
self.runModule("r.mapcalc", expression="map_a = 100 + row() + col()",
overwrite=True)
self.runModule("r.mapcalc", expression="zone_map = if(row() < 20, 1,2)",
overwrite=True)
self.runModule("r.mapcalc", expression="row_map = row()",
overwrite=True)
self.runModule("r.to.vect", input="zone_map", output="zone_map",
type="area", overwrite=True)
cols = [(u'cat', 'INTEGER PRIMARY KEY'), (u'name', 'VARCHAR(20)')]
vt = VectorTopo('test_line')
vt.open('w', tab_cols=cols)
line1 = Line([(1, 1), (2, 1), (2, 2)])
line2 = Line([(10, 20), (15, 22), (20, 32), (30, 40)])
vt.write(line1, ('first',))
vt.write(line2, ('second',))
vt.table.conn.commit()
vt.close()
vt = VectorTopo('test_small_area')
vt.open('w', tab_cols=cols)
area1 = Boundary(points=[(0, 0), (0, 0.2), (0.2, 0.2), (0.2, 0), (0, 0)])
area2 = Boundary(points=[(2.7, 2.7), (2.7, 2.8), (2.8, 2.8), (2.8, 2.7), (2.7, 2.7)])
cent1 = Centroid(x=0.1, y=0.1)
cent2 = Centroid(x=2.75, y=2.75)
vt.write(area1)
vt.write(area2)
vt.write(cent1, ('first',))
vt.write(cent2, ('second',))
vt.table.conn.commit()
vt.close()
def main():
in_vector = options["input"].split("@")[0]
if len(options["input"].split("@")) > 1:
in_mapset = options["input"].split("@")[1]
else:
in_mapset = None
raster_maps = options["raster"].split(
",") # raster file(s) to extract from
output = options["output"]
methods = tuple(options["methods"].split(","))
percentile = (None if options["percentile"] == "" else map(
float, options["percentile"].split(",")))
column_prefix = tuple(options["column_prefix"].split(","))
buffers = options["buffers"].split(",")
types = options["type"].split(",")
layer = options["layer"]
sep = options["separator"]
update = flags["u"]
tabulate = flags["t"]
percent = flags["p"]
remove = flags["r"]
use_label = flags["l"]
empty_buffer_warning = (
"No data in raster map {} within buffer {} around geometry {}")
# Do checks using pygrass
for rmap in raster_maps:
r_map = RasterAbstractBase(rmap)
if not r_map.exist():
grass.fatal("Could not find raster map {}.".format(rmap))
user_mask = False
m_map = RasterAbstractBase("MASK", Mapset().name)
if m_map.exist():
grass.warning("Current MASK is temporarily renamed.")
user_mask = True
unset_mask()
invect = VectorTopo(in_vector)
if not invect.exist():
grass.fatal("Vector file {} does not exist".format(in_vector))
if output:
if output == "-":
out = None
else:
out = open(output, "w")
# Check if input map is in current mapset (and thus editable)
if in_mapset and unicode(in_mapset) != unicode(Mapset()):
grass.fatal(
"Input vector map is not in current mapset and cannot be modified. \
Please consider copying it to current mapset.".format(
output))
buffers = []
for buf in options["buffers"].split(","):
try:
b = float(buf)
if b.is_integer():
buffers.append(int(b))
else:
buffers.append(b)
except:
grass.fatal("")
if b < 0:
grass.fatal("Negative buffer distance not supported!")
### Define column types depenting on statistic, map type and
### DB backend (SQLite supports only double and not real)
# int: statistic produces allways integer precision
# double: statistic produces allways floating point precision
# map_type: precision f statistic depends on map type
int_dict = {
"number": (0, "int", "n"),
"number_null": (1, "int", "null_cells"),
"minimum": (3, "map_type", "min"),
"maximum": (4, "map_type", "max"),
"range": (5, "map_type", "range"),
"average": (6, "double", "mean"),
"average_abs": (7, "double", "mean_of_abs"),
"stddev": (8, "double", "stddev"),
"variance": (9, "double", "variance"),
"coeff_var": (10, "double", "coeff_var"),
"sum": (11, "map_type", "sum"),
"first_quartile": (12, "map_type", "first_quartile"),
"median": (13, "map_type", "median"),
"third_quartile": (14, "map_type", "third_quartile"),
"percentile": (15, "map_type", "percentile"),
}
if len(raster_maps) != len(column_prefix):
grass.fatal(
"Number of maps and number of column prefixes has to be equal!")
# Generate list of required column names and types
col_names = []
valid_labels = []
col_types = []
for p in column_prefix:
rmaptype, val_lab, rcats = raster_type(
raster_maps[column_prefix.index(p)], tabulate, use_label)
valid_labels.append(val_lab)
for b in buffers:
b_str = str(b).replace(".", "_")
if tabulate:
if rmaptype == "double precision":
grass.fatal(
"{} has floating point precision. Can only tabulate integer maps"
.format(raster_maps[column_prefix.index(p)]))
col_names.append("{}_{}_b{}".format(p, "ncats", b_str))
col_types.append("int")
col_names.append("{}_{}_b{}".format(p, "mode", b_str))
col_types.append("int")
col_names.append("{}_{}_b{}".format(p, "null", b_str))
col_types.append("double precision")
col_names.append("{}_{}_b{}".format(p, "area_tot", b_str))
col_types.append("double precision")
for rcat in rcats:
if use_label and valid_labels:
rcat = rcat[0].replace(" ", "_")
else:
rcat = rcat[1]
col_names.append("{}_{}_b{}".format(p, rcat, b_str))
col_types.append("double precision")
else:
for m in methods:
col_names.append("{}_{}_b{}".format(
p, int_dict[m][2], b_str))
col_types.append(rmaptype if int_dict[m][1] ==
"map_type" else int_dict[m][1])
if percentile:
for perc in percentile:
col_names.append("{}_percentile_{}_b{}".format(
p,
int(perc) if (perc).is_integer() else perc, b_str))
col_types.append(rmaptype if int_dict[m][1] ==
"map_type" else int_dict[m][1])
# Open input vector map
in_vect = VectorTopo(in_vector, layer=layer)
in_vect.open(mode="r")
# Get name for temporary map
global TMP_MAPS
TMP_MAPS.append(tmp_map)
# Setup stats collectors
if tabulate:
# Collector for raster category statistics
stats = Module("r.stats", run_=False, stdout_=PIPE)
stats.inputs.sort = "desc"
stats.inputs.null_value = "null"
stats.flags.quiet = True
stats.flags.l = True
if percent:
stats.flags.p = True
stats.flags.n = True
else:
stats.flags.a = True
else:
# Collector for univariat statistics
univar = Module("r.univar", run_=False, stdout_=PIPE)
univar.inputs.separator = sep
univar.flags.g = True
univar.flags.quiet = True
# Add extended statistics if requested
if set(methods).intersection(
set(["first_quartile", "median", "third_quartile"])):
univar.flags.e = True
if percentile is not None:
univar.flags.e = True
univar.inputs.percentile = percentile
# Check if attribute table exists
if not output:
if not in_vect.table:
grass.fatal(
"No attribute table found for vector map {}".format(in_vect))
# Modify table as needed
tab = in_vect.table
tab_name = tab.name
tab_cols = tab.columns
# Add required columns
existing_cols = list(set(tab_cols.names()).intersection(col_names))
if len(existing_cols) > 0:
if not update:
in_vect.close()
grass.fatal(
"Column(s) {} already exist! Please use the u-flag \
if you want to update values in those columns".
format(",".join(existing_cols)))
else:
grass.warning("Column(s) {} already exist!".format(
",".join(existing_cols)))
for e in existing_cols:
idx = col_names.index(e)
del col_names[idx]
del col_types[idx]
tab_cols.add(col_names, col_types)
conn = tab.conn
cur = conn.cursor()
sql_str_start = "UPDATE {} SET ".format(tab_name)
elif output == "-":
print("cat{0}raster_map{0}buffer{0}statistic{0}value".format(sep))
else:
out.write("cat{0}raster_map{0}buffer{0}statistic{0}value{1}".format(
sep, os.linesep))
# Get computational region
grass.use_temp_region()
r = Region()
r.read()
# Adjust region extent to buffer around geometry
# reg = deepcopy(r)
# Create iterator for geometries of all selected types
geoms = chain()
geoms_n = 0
n_geom = 1
for geom_type in types:
geoms_n += in_vect.number_of(geom_type)
if in_vect.number_of(geom_type) > 0:
geoms = chain(in_vect.viter(geom_type))
# Loop over geometries
for geom in geoms:
# Get cat
cat = geom.cat
# Add where clause to UPDATE statement
sql_str_end = " WHERE cat = {};".format(cat)
# Loop over ser provided buffer distances
for buf in buffers:
b_str = str(buf).replace(".", "_")
# Buffer geometry
if buf <= 0:
buffer_geom = geom
else:
buffer_geom = geom.buffer(buf)
# Create temporary vector map with buffered geometry
tmp_vect = VectorTopo(tmp_map, quiet=True)
tmp_vect.open(mode="w")
tmp_vect.write(Boundary(points=buffer_geom[0].to_list()))
# , c_cats=int(cat), set_cats=True
if callable(buffer_geom[1]):
tmp_vect.write(Centroid(x=buffer_geom[1]().x,
y=buffer_geom[1]().y),
cat=int(cat))
else:
tmp_vect.write(Centroid(x=buffer_geom[1].x,
y=buffer_geom[1].y),
cat=int(cat))
#################################################
# How to silence VectorTopo???
#################################################
# Save current stdout
# original = sys.stdout
# f = open(os.devnull, 'w')
# with open('output.txt', 'w') as f:
# sys.stdout = io.BytesIO()
# sys.stdout.fileno() = os.devnull
# sys.stderr = f
# os.environ.update(dict(GRASS_VERBOSE='0'))
tmp_vect.close(build=False)
grass.run_command("v.build", map=tmp_map, quiet=True)
# os.environ.update(dict(GRASS_VERBOSE='1'))
# reg = Region()
# reg.read()
# r.from_vect(tmp_map)
r = align_current(r, buffer_geom[0].bbox())
r.write()
# Check if the following is needed
# needed specially with r.stats -p
# grass.run_command('g.region', vector=tmp_map, flags='a')
# Create a MASK from buffered geometry
if user_mask:
grass.run_command(
"v.to.rast",
input=tmp_map,
output=tmp_map,
use="val",
value=int(cat),
quiet=True,
)
mc_expression = (
"MASK=if(!isnull({0}) && !isnull({0}_MASK), {1}, null())".
format(tmp_map, cat))
grass.run_command("r.mapcalc",
expression=mc_expression,
quiet=True)
else:
grass.run_command(
"v.to.rast",
input=tmp_map,
output="MASK",
use="val",
value=int(cat),
quiet=True,
)
# reg.write()
updates = []
# Compute statistics for every raster map
for rm, rmap in enumerate(raster_maps):
# rmap = raster_maps[rm]
prefix = column_prefix[rm]
if tabulate:
# Get statistics on occurrence of raster categories within buffer
stats.inputs.input = rmap
stats.run()
t_stats = (stats.outputs["stdout"].value.rstrip(
os.linesep).replace(" ", " ").replace(
"no data", "no_data").replace(
" ",
"_b{} = ".format(b_str)).split(os.linesep))
if t_stats == [""]:
grass.warning(
empty_buffer_warning.format(rmap, buf, cat))
continue
if (t_stats[0].split(
"_b{} = ".format(b_str))[0].split("_")[-1] !=
"null"):
mode = (t_stats[0].split(
"_b{} = ".format(b_str))[0].split("_")[-1])
elif len(t_stats) == 1:
mode = "NULL"
else:
mode = (t_stats[1].split(
"_b{} = ".format(b_str))[0].split("_")[-1])
if not output:
updates.append("\t{}_{}_b{} = {}".format(
prefix, "ncats", b_str, len(t_stats)))
updates.append("\t{}_{}_b{} = {}".format(
prefix, "mode", b_str, mode))
area_tot = 0
for l in t_stats:
# check if raster maps has category or not
if len(l.split("=")) == 2:
updates.append("\t{}_{}".format(
prefix, l.rstrip("%")))
elif not l.startswith("null"):
vals = l.split("=")
updates.append("\t{}_{} = {}".format(
prefix,
vals[-2].strip()
if valid_labels[rm] else vals[0].strip(),
vals[-1].strip().rstrip("%"),
))
if not l.startswith("null"):
area_tot += float(
l.rstrip("%").split("= ")[-1])
if not percent:
updates.append("\t{}_{}_b{} = {}".format(
prefix, "area_tot", b_str, area_tot))
else:
out_str = "{1}{0}{2}{0}{3}{0}{4}{0}{5}{6}".format(
sep, cat, prefix, buf, "ncats", len(t_stats),
os.linesep)
out_str += "{1}{0}{2}{0}{3}{0}{4}{0}{5}{6}".format(
sep, cat, prefix, buf, "mode", mode, os.linesep)
area_tot = 0
for l in t_stats:
rcat = (l.split("= ")[1].rstrip(
"_b{} = ".format(b_str))
if valid_labels[rm] else l.split("_")[0])
area = l.split("= ")[-1]
out_str += "{1}{0}{2}{0}{3}{0}{4}{0}{5}{6}".format(
sep,
cat,
prefix,
buf,
"area {}".format(rcat),
area,
os.linesep,
)
if rcat != "null":
area_tot = area_tot + float(
l.rstrip("%").split("= ")[-1])
if not percent:
out_str += "{1}{0}{2}{0}{3}{0}{4}{0}{5}{6}".format(
sep,
cat,
prefix,
buf,
"area total",
area_tot,
os.linesep,
)
if output == "-":
print(out_str.rstrip(os.linesep))
else:
out.write(out_str)
else:
# Get univariate statistics within buffer
univar.inputs.map = rmap
univar.run()
u_stats = (univar.outputs["stdout"].value.rstrip(
os.linesep).replace(
"=", "_b{} = ".format(b_str)).split(os.linesep))
# Test if u_stats is empty and give warning
# Needs to be adjusted to number of requested stats?
if ((percentile and len(u_stats) < 14)
or (univar.flags.e and len(u_stats) < 13)
or len(u_stats) < 12):
grass.warning(
empty_buffer_warning.format(rmap, buf, cat))
break
# Extract statistics for selected methods
for m in methods:
if not output:
# Add to list of UPDATE statements
updates.append("\t{}_{}".format(
prefix,
u_stats[int_dict[m][0]] if is_number(
u_stats[int_dict[m][0]].split(" = ")[1])
else " = ".join([
u_stats[int_dict[m][0]].split(" = ")[0],
"NULL",
]),
))
else:
out_str = "{1}{0}{2}{0}{3}{0}{4}{0}{5}".format(
sep,
cat,
prefix,
buf,
m,
u_stats[int_dict[m][0]].split("= ")[1],
)
if output == "-":
print(out_str)
else:
out.write("{}{}".format(out_str, os.linesep))
if percentile:
perc_count = 0
for perc in percentile:
if not output:
updates.append(
"{}_percentile_{}_b{} = {}".format(
p,
int(perc) if
(perc).is_integer() else perc,
b_str,
u_stats[15 +
perc_count].split("= ")[1],
))
else:
out_str = "{1}{0}{2}{0}{3}{0}{4}{0}{5}".format(
sep,
cat,
prefix,
buf,
"percentile_{}".format(
int(perc) if (
perc).is_integer() else perc),
u_stats[15 + perc_count].split("= ")[1],
)
if output == "-":
print(out_str)
else:
out.write(out_str)
perc_count = perc_count + 1
if not output and len(updates) > 0:
cur.execute("{}{}{}".format(sql_str_start, ",\n".join(updates),
sql_str_end))
# Remove temporary maps
# , stderr=os.devnull, stdout_=os.devnull)
grass.run_command("g.remove",
flags="f",
type="raster",
name="MASK",
quiet=True)
grass.run_command("g.remove",
flags="f",
type="vector",
name=tmp_map,
quiet=True)
# Give progress information
grass.percent(n_geom, geoms_n, 1)
n_geom = n_geom + 1
if not output:
conn.commit()
# Close cursor and DB connection
if not output and not output == "-":
cur.close()
conn.close()
# Update history
grass.vector.vector_history(in_vector)
elif output != "-":
# write results to file
out.close()
if remove and not output:
dropcols = []
selectnum = "select count({}) from {}"
for i in col_names:
thisrow = grass.read_command("db.select",
flags="c",
sql=selectnum.format(i, in_vector))
if int(thisrow) == 0:
dropcols.append(i)
grass.debug("Columns to delete: {}".format(", ".join(dropcols)),
debug=2)
if dropcols:
grass.run_command("v.db.dropcolumn",
map=in_vector,
columns=dropcols)
def main():
"""Do the main processing
"""
# Parse input options:
patch_map = options['input']
patches = patch_map.split('@')[0]
patches_mapset = patch_map.split('@')[1] if len(
patch_map.split('@')) > 1 else None
pop_proxy = options['pop_proxy']
layer = options['layer']
costs = options['costs']
cutoff = float(options['cutoff'])
border_dist = int(options['border_dist'])
conefor_dir = options['conefor_dir']
memory = int(options['memory'])
# Parse output options:
prefix = options['prefix']
edge_map = '{}_edges'.format(prefix)
vertex_map = '{}_vertices'.format(prefix)
shortest_paths = '{}_shortest_paths'.format(prefix)
# Parse flags:
p_flag = flags['p']
t_flag = flags['t']
r_flag = flags['r']
dist_flags = 'kn' if flags['k'] else 'n'
lin_cat = 1
zero_dist = None
folder = grass.tempdir()
if not os.path.exists(folder):
os.makedirs(folder)
# Setup counter for progress message
counter = 0
# Check if location is lat/lon (only in lat/lon geodesic distance
# measuring is supported)
if grass.locn_is_latlong():
grass.verbose("Location is lat/lon: Geodesic distance \
measure is used")
# Check if prefix is legal GRASS name
if not grass.legal_name(prefix):
grass.fatal('{} is not a legal name for GRASS \
maps.'.format(prefix))
if prefix[0].isdigit():
grass.fatal('Tables names starting with a digit are not SQL \
compliant.'.format(prefix))
# Check if output maps not already exists or could be overwritten
for output in [edge_map, vertex_map, shortest_paths]:
if grass.db.db_table_exist(output) and not grass.overwrite():
grass.fatal('Vector map <{}> already exists'.format(output))
# Check if input has required attributes
in_db_connection = grass.vector.vector_db(patch_map)
if not int(layer) in in_db_connection.keys():
grass.fatal('No attribute table connected vector map {} at \
layer {}.'.format(patches, layer))
#Check if cat column exists
pcols = grass.vector.vector_columns(patch_map, layer=layer)
#Check if cat column exists
if not 'cat' in pcols.keys():
grass.fatal('Cannot find the reqired column cat in vector map \
{}.'.format(patches))
#Check if pop_proxy column exists
if not pop_proxy in pcols.keys():
grass.fatal('Cannot find column {} in vector map \
{}'.format(pop_proxy, patches))
#Check if pop_proxy column is numeric type
if not pcols[pop_proxy]['type'] in ['INTEGER', 'REAL', 'DOUBLE PRECISION']:
grass.fatal('Column {} is of type {}. Only numeric types \
(integer or double precision) \
allowed!'.format(pop_proxy, pcols[pop_proxy]['type']))
#Check if pop_proxy column does not contain values <= 0
pop_vals = np.fromstring(grass.read_command('v.db.select',
flags='c',
map=patches,
columns=pop_proxy,
nv=-9999).rstrip('\n'),
dtype=float,
sep='\n')
if np.min(pop_vals) <= 0:
grass.fatal('Column {} contains values <= 0 or NULL. Neither \
values <= 0 nor NULL allowed!}'.format(pop_proxy))
##############################################
# Use pygrass region instead of grass.parse_command !?!
start_reg = grass.parse_command('g.region', flags='ugp')
max_n = start_reg['n']
min_s = start_reg['s']
max_e = start_reg['e']
min_w = start_reg['w']
# cost_nsres = reg['nsres']
# cost_ewres = reg['ewres']
# Rasterize patches
# http://www.gdal.org/gdal_tutorial.html
# http://geoinformaticstutorial.blogspot.no/2012/11/convert-
# shapefile-to-raster-with-gdal.html
if t_flag:
# Rasterize patches with "all-touched" mode using GDAL
# Read region-settings (not needed canuse max_n, min_s, max_e,
# min_w nsres, ewres...
prast = os.path.join(folder, 'patches_rast.tif')
# Check if GDAL-GRASS plugin is installed
if ogr.GetDriverByName('GRASS'):
#With GDAL-GRASS plugin
#Locate file for patch vector map
pfile = grass.parse_command('g.findfile',
element='vector',
file=patches,
mapset=patches_mapset)['file']
pfile = os.path.join(pfile, 'head')
else:
# Without GDAL-GRASS-plugin
grass.warning("Cannot find GDAL-GRASS plugin. Consider \
installing it in order to save time for \
all-touched rasterisation")
pfile = os.path.join(folder, 'patches_vect.gpkg')
# Export patch vector map to temp-file in a GDAL-readable
# format (shp)
grass.run_command('v.out.ogr',
flags='m',
quiet=True,
input=patch_map,
type='area',
layer=layer,
output=pfile,
lco='GEOMETRY_NAME=geom')
# Rasterize vector map with all-touched option
os.system('gdal_rasterize -l {} -at -tr {} {} \
-te {} {} {} {} -ot Uint32 -a cat \
{} {} -q'.format(patches, start_reg['ewres'],
start_reg['nsres'], start_reg['w'],
start_reg['s'], start_reg['e'],
start_reg['n'], pfile, prast))
if not ogr.GetDriverByName('GRASS'):
# Remove vector temp-file
os.remove(os.path.join(folder, 'patches_vect.gpkg'))
# Import rasterized patches
grass.run_command('r.external',
flags='o',
quiet=True,
input=prast,
output='{}_patches_pol'.format(TMP_PREFIX))
else:
# Simple rasterisation (only area)
# in G 7.6 also with support for 'centroid'
if float(grass.version()['version'][:3]) >= 7.6:
conv_types = ['area', 'centroid']
else:
conv_types = ['area']
grass.run_command('v.to.rast',
quiet=True,
input=patches,
use='cat',
type=conv_types,
output='{}_patches_pol'.format(TMP_PREFIX))
# Extract boundaries from patch raster map
grass.run_command('r.mapcalc',
expression='{p}_patches_boundary=if(\
{p}_patches_pol,\
if((\
(isnull({p}_patches_pol[-1,0])||| \
{p}_patches_pol[-1,0]!={p}_patches_pol)||| \
(isnull({p}_patches_pol[0,1])||| \
{p}_patches_pol[0,1]!={p}_patches_pol)||| \
(isnull({p}_patches_pol[1,0])||| \
{p}_patches_pol[1,0]!={p}_patches_pol)||| \
(isnull({p}_patches_pol[0,-1])||| \
{p}_patches_pol[0,-1]!={p}_patches_pol)), \
{p}_patches_pol,null()), null())'.format(p=TMP_PREFIX),
quiet=True)
rasterized_cats = grass.read_command(
'r.category',
separator='newline',
map='{p}_patches_boundary'.format(p=TMP_PREFIX)).replace(
'\t', '').strip('\n')
rasterized_cats = list(
map(int, set([x for x in rasterized_cats.split('\n') if x != ''])))
#Init output vector maps if they are requested by user
network = VectorTopo(edge_map)
network_columns = [(u'cat', 'INTEGER PRIMARY KEY'), (u'from_p', 'INTEGER'),
(u'to_p', 'INTEGER'), (u'min_dist', 'DOUBLE PRECISION'),
(u'dist', 'DOUBLE PRECISION'),
(u'max_dist', 'DOUBLE PRECISION')]
network.open('w', tab_name=edge_map, tab_cols=network_columns)
vertex = VectorTopo(vertex_map)
vertex_columns = [
(u'cat', 'INTEGER PRIMARY KEY'),
(pop_proxy, 'DOUBLE PRECISION'),
]
vertex.open('w', tab_name=vertex_map, tab_cols=vertex_columns)
if p_flag:
# Init cost paths file for start-patch
grass.run_command('v.edit',
quiet=True,
map=shortest_paths,
tool='create')
grass.run_command('v.db.addtable',
quiet=True,
map=shortest_paths,
columns="cat integer,\
from_p integer,\
to_p integer,\
dist_min double precision,\
dist double precision,\
dist_max double precision")
start_region_bbox = Bbox(north=float(max_n),
south=float(min_s),
east=float(max_e),
west=float(min_w))
vpatches = VectorTopo(patches, mapset=patches_mapset)
vpatches.open('r', layer=int(layer))
###Loop through patches
vpatch_ids = np.array(vpatches.features_to_wkb_list(
feature_type="centroid", bbox=start_region_bbox),
dtype=[('vid', 'uint32'), ('cat', 'uint32'),
('geom', '|S10')])
cats = set(vpatch_ids['cat'])
n_cats = len(cats)
if n_cats < len(vpatch_ids['cat']):
grass.verbose('At least one MultiPolygon found in patch map.\n \
Using average coordinates of the centroids for \
visual representation of the patch.')
for cat in cats:
if cat not in rasterized_cats:
grass.warning('Patch {} has not been rasterized and will \
therefore not be treated as part of the \
network. Consider using t-flag or change \
resolution.'.format(cat))
continue
grass.verbose("Calculating connectivity-distances for patch \
number {}".format(cat))
# Filter
from_vpatch = vpatch_ids[vpatch_ids['cat'] == cat]
# Get patch ID
if from_vpatch['vid'].size == 1:
from_centroid = Centroid(v_id=int(from_vpatch['vid']),
c_mapinfo=vpatches.c_mapinfo)
from_x = from_centroid.x
from_y = from_centroid.y
# Get centroid
if not from_centroid:
continue
else:
xcoords = []
ycoords = []
for f_p in from_vpatch['vid']:
from_centroid = Centroid(v_id=int(f_p),
c_mapinfo=vpatches.c_mapinfo)
xcoords.append(from_centroid.x)
ycoords.append(from_centroid.y)
# Get centroid
if not from_centroid:
continue
from_x = np.average(xcoords)
from_y = np.average(ycoords)
# Get BoundingBox
from_bbox = grass.parse_command('v.db.select',
map=patch_map,
flags='r',
where='cat={}'.format(cat))
attr_filter = vpatches.table.filters.select(pop_proxy)
attr_filter = attr_filter.where("cat={}".format(cat))
proxy_val = vpatches.table.execute().fetchone()
# Prepare start patch
start_patch = '{}_patch_{}'.format(TMP_PREFIX, cat)
reclass_rule = grass.encode('{} = 1\n* = NULL'.format(cat))
recl = grass.feed_command(
'r.reclass',
quiet=True,
input='{}_patches_boundary'.format(TMP_PREFIX),
output=start_patch,
rules='-')
recl.stdin.write(reclass_rule)
recl.stdin.close()
recl.wait()
# Check if patch was rasterised (patches smaller raster resolution and close to larger patches may not be rasterised)
#start_check = grass.parse_command('r.info', flags='r', map=start_patch)
#start_check = grass.parse_command('r.univar', flags='g', map=start_patch)
#print(start_check)
"""if start_check['min'] != '1':
grass.warning('Patch {} has not been rasterized and will \
therefore not be treated as part of the \
network. Consider using t-flag or change \
resolution.'.format(cat))
grass.run_command('g.remove', flags='f', vector=start_patch,
raster=start_patch, quiet=True)
grass.del_temp_region()
continue"""
# Prepare stop patches
############################################
reg = grass.parse_command('g.region',
flags='ug',
quiet=True,
raster=start_patch,
n=float(from_bbox['n']) + float(cutoff),
s=float(from_bbox['s']) - float(cutoff),
e=float(from_bbox['e']) + float(cutoff),
w=float(from_bbox['w']) - float(cutoff),
align='{}_patches_pol'.format(TMP_PREFIX))
north = reg['n'] if max_n > reg['n'] else max_n
south = reg['s'] if min_s < reg['s'] else min_s
east = reg['e'] if max_e < reg['e'] else max_e
west = reg['w'] if min_w > reg['w'] else min_w
# Set region to patch search radius
grass.use_temp_region()
grass.run_command('g.region',
quiet=True,
n=north,
s=south,
e=east,
w=west,
align='{}_patches_pol'.format(TMP_PREFIX))
# Create buffer around start-patch as a mask
# for cost distance analysis
grass.run_command('r.buffer',
quiet=True,
input=start_patch,
output='MASK',
distances=cutoff)
grass.run_command('r.mapcalc',
quiet=True,
expression='{pf}_patch_{p}_neighbours_contur=\
if({pf}_patches_boundary=={p},\
null(),\
{pf}_patches_boundary)'.format(
pf=TMP_PREFIX, p=cat))
grass.run_command('r.mask', flags='r', quiet=True)
# Calculate cost distance
cost_distance_map = '{}_patch_{}_cost_dist'.format(prefix, cat)
grass.run_command('r.cost',
flags=dist_flags,
quiet=True,
overwrite=True,
input=costs,
output=cost_distance_map,
start_rast=start_patch,
memory=memory)
#grass.run_command('g.region', flags='up')
# grass.raster.raster_history(cost_distance_map)
cdhist = History(cost_distance_map)
cdhist.clear()
cdhist.creator = os.environ['USER']
cdhist.write()
# History object cannot modify description
grass.run_command('r.support',
map=cost_distance_map,
description='Generated by r.connectivity.distance',
history=os.environ['CMDLINE'])
# Export distance at boundaries
maps = '{0}_patch_{1}_neighbours_contur,{2}_patch_{1}_cost_dist'
maps = maps.format(TMP_PREFIX, cat, prefix),
connections = grass.encode(
grass.read_command('r.stats',
flags='1ng',
quiet=True,
input=maps,
separator=';').rstrip('\n'))
if connections:
con_array = np.genfromtxt(BytesIO(connections),
delimiter=';',
dtype=None,
names=['x', 'y', 'cat', 'dist'])
else:
grass.warning('No connections for patch {}'.format(cat))
# Write centroid to vertex map
vertex.write(Point(from_x, from_y), cat=int(cat), attrs=proxy_val)
vertex.table.conn.commit()
# Remove temporary map data
grass.run_command('g.remove',
quiet=True,
flags='f',
type=['raster', 'vector'],
pattern="{}*{}*".format(TMP_PREFIX, cat))
grass.del_temp_region()
continue
#Find closest points on neigbour patches
to_cats = set(np.atleast_1d(con_array['cat']))
to_coords = []
for to_cat in to_cats:
connection = con_array[con_array['cat'] == to_cat]
connection.sort(order=['dist'])
pixel = border_dist if len(
connection) > border_dist else len(connection) - 1
# closest_points_x = connection['x'][pixel]
# closest_points_y = connection['y'][pixel]
closest_points_to_cat = to_cat
closest_points_min_dist = connection['dist'][0]
closest_points_dist = connection['dist'][pixel]
closest_points_max_dist = connection['dist'][-1]
to_patch_ids = vpatch_ids[vpatch_ids['cat'] == int(to_cat)]['vid']
if len(to_patch_ids) == 1:
to_centroid = Centroid(v_id=to_patch_ids,
c_mapinfo=vpatches.c_mapinfo)
to_x = to_centroid.x
to_y = to_centroid.y
elif len(to_patch_ids) >= 1:
xcoords = []
ycoords = []
for t_p in to_patch_ids:
to_centroid = Centroid(v_id=int(t_p),
c_mapinfo=vpatches.c_mapinfo)
xcoords.append(to_centroid.x)
ycoords.append(to_centroid.y)
# Get centroid
if not to_centroid:
continue
to_x = np.average(xcoords)
to_y = np.average(ycoords)
to_coords.append('{},{},{},{},{},{}'.format(
connection['x'][0], connection['y'][0], to_cat,
closest_points_min_dist, closest_points_dist,
closest_points_max_dist))
#Save edges to network dataset
if closest_points_dist <= 0:
zero_dist = 1
# Write data to network
network.write(Line([(from_x, from_y), (to_x, to_y)]),
cat=lin_cat,
attrs=(
cat,
int(closest_points_to_cat),
closest_points_min_dist,
closest_points_dist,
closest_points_max_dist,
))
network.table.conn.commit()
lin_cat = lin_cat + 1
# Save closest points and shortest paths through cost raster as
# vector map (r.drain limited to 1024 points) if requested
if p_flag:
grass.verbose('Extracting shortest paths for patch number \
{}...'.format(cat))
points_n = len(to_cats)
tiles = int(points_n / 1024.0)
rest = points_n % 1024
if not rest == 0:
tiles = tiles + 1
tile_n = 0
while tile_n < tiles:
tile_n = tile_n + 1
#Import closest points for start-patch in 1000er blocks
sp = grass.feed_command('v.in.ascii',
flags='nr',
overwrite=True,
quiet=True,
input='-',
stderr=subprocess.PIPE,
output="{}_{}_cp".format(
TMP_PREFIX, cat),
separator=",",
columns="x double precision,\
y double precision,\
to_p integer,\
dist_min double precision,\
dist double precision,\
dist_max double precision")
sp.stdin.write(grass.encode("\n".join(to_coords)))
sp.stdin.close()
sp.wait()
# Extract shortest paths for start-patch in chunks of
# 1024 points
cost_paths = "{}_{}_cost_paths".format(TMP_PREFIX, cat)
start_points = "{}_{}_cp".format(TMP_PREFIX, cat)
grass.run_command('r.drain',
overwrite=True,
quiet=True,
input=cost_distance_map,
output=cost_paths,
drain=cost_paths,
start_points=start_points)
grass.run_command('v.db.addtable',
map=cost_paths,
quiet=True,
columns="cat integer,\
from_p integer,\
to_p integer,\
dist_min double precision,\
dist double precision,\
dist_max double precision")
grass.run_command('v.db.update',
map=cost_paths,
column='from_p',
value=cat,
quiet=True)
grass.run_command('v.distance',
quiet=True,
from_=cost_paths,
to=start_points,
upload='to_attr',
column='to_p',
to_column='to_p')
grass.run_command('v.db.join',
quiet=True,
map=cost_paths,
column='to_p',
other_column='to_p',
other_table=start_points,
subset_columns='dist_min,dist,dist_max')
#grass.run_command('v.info', flags='c',
# map=cost_paths)
grass.run_command('v.patch',
flags='ae',
overwrite=True,
quiet=True,
input=cost_paths,
output=shortest_paths)
# Remove temporary map data
grass.run_command('g.remove',
quiet=True,
flags='f',
type=['raster', 'vector'],
pattern="{}*{}*".format(TMP_PREFIX, cat))
# Remove temporary map data for patch
if r_flag:
grass.run_command('g.remove',
flags='f',
type='raster',
name=cost_distance_map,
quiet=True)
vertex.write(Point(from_x, from_y), cat=int(cat), attrs=proxy_val)
vertex.table.conn.commit()
# Print progress message
grass.percent(i=int((float(counter) / n_cats) * 100), n=100, s=3)
# Update counter for progress message
counter = counter + 1
if zero_dist:
grass.warning('Some patches are directly adjacent to others. \
Minimum distance set to 0.0000000001')
# Close vector maps and build topology
network.close()
vertex.close()
# Add vertex attributes
# grass.run_command('v.db.addtable', map=vertex_map)
# grass.run_command('v.db.join', map=vertex_map, column='cat',
# other_table=in_db_connection[int(layer)]['table'],
# other_column='cat', subset_columns=pop_proxy,
# quiet=True)
# Add history and meta data to produced maps
grass.run_command('v.support',
flags='h',
map=edge_map,
person=os.environ['USER'],
cmdhist=os.environ['CMDLINE'])
grass.run_command('v.support',
flags='h',
map=vertex_map,
person=os.environ['USER'],
cmdhist=os.environ['CMDLINE'])
if p_flag:
grass.run_command('v.support',
flags='h',
map=shortest_paths,
person=os.environ['USER'],
cmdhist=os.environ['CMDLINE'])
# Output also Conefor files if requested
if conefor_dir:
query = """SELECT p_from, p_to, avg(dist) FROM
(SELECT
CASE
WHEN from_p > to_p THEN to_p
ELSE from_p END AS p_from,
CASE
WHEN from_p > to_p THEN from_p
ELSE to_p END AS p_to,
dist
FROM {}) AS x
GROUP BY p_from, p_to""".format(edge_map)
with open(os.path.join(conefor_dir, 'undirected_connection_file'),
'w') as edges:
edges.write(
grass.read_command('db.select', sql=query, separator=' '))
with open(os.path.join(conefor_dir, 'directed_connection_file'),
'w') as edges:
edges.write(
grass.read_command('v.db.select',
map=edge_map,
separator=' ',
flags='c'))
with open(os.path.join(conefor_dir, 'node_file'), 'w') as nodes:
nodes.write(
grass.read_command('v.db.select',
map=vertex_map,
separator=' ',
flags='c'))
def create_test_vector_map(map_name="test_vector"):
"""This functions creates a vector map layer with points, lines, boundaries,
centroids, areas, isles and attributes for testing purposes
This should be used in doc and unit tests to create location/mapset
independent vector map layer. This map includes 3 points, 3 lines,
11 boundaries and 4 centroids. The attribute table contains cat, name
and value columns.
param map_name: The vector map name that should be used
P1 P2 P3
6 * * *
5
4 _______ ___ ___ L1 L2 L3
Y 3 |A1___ *| *| *| | | |
2 | |A2*| | | | | | |
1 | |___| |A3 |A4 | | | |
0 |_______|___|___| | | |
-1
-1 0 1 2 3 4 5 6 7 8 9 10 12 14
X
"""
from grass.pygrass.vector import VectorTopo
from grass.pygrass.vector.geometry import Point, Line, Centroid, Boundary
cols = [
("cat", "INTEGER PRIMARY KEY"),
("name", "varchar(50)"),
("value", "double precision"),
]
with VectorTopo(map_name, mode="w", tab_name=map_name,
tab_cols=cols) as vect:
# Write 3 points
vect.write(Point(10, 6), cat=1, attrs=("point", 1))
vect.write(Point(12, 6), cat=1)
vect.write(Point(14, 6), cat=1)
# Write 3 lines
vect.write(Line([(10, 4), (10, 2), (10, 0)]), cat=2, attrs=("line", 2))
vect.write(Line([(12, 4), (12, 2), (12, 0)]), cat=2)
vect.write(Line([(14, 4), (14, 2), (14, 0)]), cat=2)
# boundaries 1 - 4
vect.write(Boundary(points=[(0, 0), (0, 4)]))
vect.write(Boundary(points=[(0, 4), (4, 4)]))
vect.write(Boundary(points=[(4, 4), (4, 0)]))
vect.write(Boundary(points=[(4, 0), (0, 0)]))
# 5. boundary (Isle)
vect.write(Boundary(points=[(1, 1), (1, 3), (3, 3), (3, 1), (1, 1)]))
# boundaries 6 - 8
vect.write(Boundary(points=[(4, 4), (6, 4)]))
vect.write(Boundary(points=[(6, 4), (6, 0)]))
vect.write(Boundary(points=[(6, 0), (4, 0)]))
# boundaries 9 - 11
vect.write(Boundary(points=[(6, 4), (8, 4)]))
vect.write(Boundary(points=[(8, 4), (8, 0)]))
vect.write(Boundary(points=[(8, 0), (6, 0)]))
# Centroids, all have the same cat and attribute
vect.write(Centroid(x=3.5, y=3.5), cat=3, attrs=("centroid", 3))
vect.write(Centroid(x=2.5, y=2.5), cat=3)
vect.write(Centroid(x=5.5, y=3.5), cat=3)
vect.write(Centroid(x=7.5, y=3.5), cat=3)
vect.organization = "Thuenen Institut"
vect.person = "Soeren Gebbert"
vect.title = "Test dataset"
vect.comment = "This is a comment"
vect.table.conn.commit()
vect.organization = "Thuenen Institut"
vect.person = "Soeren Gebbert"
vect.title = "Test dataset"
vect.comment = "This is a comment"
vect.close()
def main():
in_vector = options['input'].split('@')[0]
if len(options['input'].split('@')) > 1:
in_mapset = options['input'].split('@')[1]
else:
in_mapset = None
raster_maps = options['raster'].split(',') # raster file(s) to extract from
output = options['output']
methods = tuple(options['methods'].split(','))
percentile = None if options['percentile'] == '' else map(float, options['percentile'].split(','))
column_prefix = tuple(options['column_prefix'].split(','))
buffers = options['buffers'].split(',')
types = options['type'].split(',')
layer = options['layer']
sep = options['separator']
update = flags['u']
tabulate = flags['t']
percent = flags['p']
remove = flags['r']
use_lable = False
empty_buffer_warning = 'No data in raster map {} within buffer {} around geometry {}'
# Do checks using pygrass
for rmap in raster_maps:
r_map = RasterAbstractBase(rmap)
if not r_map.exist():
grass.fatal('Could not find raster map {}.'.format(rmap))
user_mask = False
m_map = RasterAbstractBase('MASK', Mapset().name)
if m_map.exist():
grass.warning("Current MASK is temporarily renamed.")
user_mask = True
unset_mask()
invect = VectorTopo(in_vector)
if not invect.exist():
grass.fatal("Vector file {} does not exist".format(in_vector))
if output:
if output == '-':
out = None
else:
out = open(output, 'w')
# Check if input map is in current mapset (and thus editable)
if in_mapset and unicode(in_mapset) != unicode(Mapset()):
grass.fatal("Input vector map is not in current mapset and cannot be modified. \
Please consider copying it to current mapset.".format(output))
buffers = []
for buf in options['buffers'].split(','):
try:
b = float(buf)
if b.is_integer():
buffers.append(int(b))
else:
buffers.append(b)
except:
grass.fatal('')
if b < 0:
grass.fatal("Negative buffer distance not supported!")
### Define column types depenting on statistic, map type and
### DB backend (SQLite supports only double and not real)
# int: statistic produces allways integer precision
# double: statistic produces allways floating point precision
# map_type: precision f statistic depends on map type
int_dict = {'number': (0, 'int', 'n'),
'number_null': (1, 'int', 'null_cells'),
'minimum': (3, 'map_type', 'min'),
'maximum': (4, 'map_type', 'max'),
'range': (5, 'map_type', 'range'),
'average': (6, 'double', 'mean'),
'average_abs': (7, 'double', 'mean_of_abs'),
'stddev': (8, 'double', 'stddev'),
'variance': (9, 'double', 'variance'),
'coeff_var': (10, 'double', 'coeff_var'),
'sum': (11, 'map_type', 'sum'),
'first_quartile': (12, 'map_type', 'first_quartile'),
'median': (13, 'map_type', 'median'),
'third_quartile': (14, 'map_type', 'third_quartile'),
'percentile': (15, 'map_type', 'percentile')}
if len(raster_maps) != len(column_prefix):
grass.fatal('Number of maps and number of column prefixes has to be equal!')
# Generate list of required column names and types
col_names = []
col_types = []
for p in column_prefix:
rmaptype, rcats = raster_type(raster_maps[column_prefix.index(p)], tabulate, use_lable)
for b in buffers:
b_str = str(b).replace('.', '_')
if tabulate:
if rmaptype == 'double precision':
grass.fatal('{} has floating point precision. Can only tabulate integer maps'.format(raster_maps[column_prefix.index(p)]))
col_names.append('{}_{}_b{}'.format(p, 'ncats', b_str))
col_types.append('int')
col_names.append('{}_{}_b{}'.format(p, 'mode', b_str))
col_types.append('int')
col_names.append('{}_{}_b{}'.format(p, 'null', b_str))
col_types.append('double precision')
col_names.append('{}_{}_b{}'.format(p, 'area_tot', b_str))
col_types.append('double precision')
for rcat in rcats:
if use_lable:
rcat = rcat[1].replace(" ", "_")
else:
rcat = rcat[0]
col_names.append('{}_{}_b{}'.format(p, rcat, b_str))
col_types.append('double precision')
else:
for m in methods:
col_names.append('{}_{}_b{}'.format(p, int_dict[m][2], b_str))
col_types.append(rmaptype if int_dict[m][1] == 'map_type' else int_dict[m][1])
if percentile:
for perc in percentile:
col_names.append('{}_percentile_{}_b{}'.format(p,
int(perc) if (perc).is_integer() else perc,
b_str))
col_types.append(rmaptype if int_dict[m][1] == 'map_type' else int_dict[m][1])
# Open input vector map
in_vect = VectorTopo(in_vector, layer=layer)
in_vect.open(mode='r')
# Get name for temporary map
TMP_MAPS.append(tmp_map)
# Setup stats collectors
if tabulate:
# Collector for raster category statistics
stats = Module('r.stats', run_=False, stdout_=PIPE)
stats.inputs.sort = 'desc'
stats.inputs.null_value = 'null'
stats.flags.quiet = True
if percent:
stats.flags.p = True
stats.flags.n = True
else:
stats.flags.a = True
else:
# Collector for univariat statistics
univar = Module('r.univar', run_=False, stdout_=PIPE)
univar.inputs.separator = sep
univar.flags.g = True
univar.flags.quiet = True
# Add extended statistics if requested
if set(methods).intersection(set(['first_quartile',
'median', 'third_quartile'])):
univar.flags.e = True
if percentile is not None:
univar.flags.e = True
univar.inputs.percentile = percentile
# Check if attribute table exists
if not output:
if not in_vect.table:
grass.fatal('No attribute table found for vector map {}'.format(in_vect))
# Modify table as needed
tab = in_vect.table
tab_name = tab.name
tab_cols = tab.columns
# Add required columns
existing_cols = list(set(tab_cols.names()).intersection(col_names))
if len(existing_cols) > 0:
if not update:
grass.fatal('Column(s) {} already exist! Please use the u-flag \
if you want to update values in those columns'.format(','.join(existing_cols)))
else:
grass.warning('Column(s) {} already exist!'.format(','.join(existing_cols)))
for e in existing_cols:
idx = col_names.index(e)
del col_names[idx]
del col_types[idx]
tab_cols.add(col_names, col_types)
conn = tab.conn
cur = conn.cursor()
sql_str_start = 'UPDATE {} SET '.format(tab_name)
elif output == '-':
print('cat{0}raster_map{0}buffer{0}statistic{0}value'.format(sep))
else:
out.write('cat{0}raster_map{0}buffer{0}statistic{0}value{1}'.format(sep, os.linesep))
# Get computational region
grass.use_temp_region()
r = Region()
r.read()
# Adjust region extent to buffer around geometry
#reg = deepcopy(r)
# Create iterator for geometries of all selected types
geoms = chain()
geoms_n = 0
n_geom = 1
for geom_type in types:
geoms_n += in_vect.number_of(geom_type)
if in_vect.number_of(geom_type) > 0:
geoms = chain(in_vect.viter(geom_type))
# Loop over geometries
for geom in geoms:
# Get cat
cat = geom.cat
# Add where clause to UPDATE statement
sql_str_end = ' WHERE cat = {};'.format(cat)
# Loop over ser provided buffer distances
for buf in buffers:
b_str = str(buf).replace('.', '_')
# Buffer geometry
if buf <= 0:
buffer_geom = geom
else:
buffer_geom = geom.buffer(buf)
# Create temporary vector map with buffered geometry
tmp_vect = VectorTopo(tmp_map, quiet=True)
tmp_vect.open(mode='w')
#print(int(cat))
tmp_vect.write(Boundary(points=buffer_geom[0].to_list()))
# , c_cats=int(cat), set_cats=True
tmp_vect.write(Centroid(x=buffer_geom[1].x,
y=buffer_geom[1].y), cat=int(cat))
#################################################
# How to silence VectorTopo???
#################################################
# Save current stdout
#original = sys.stdout
#f = open(os.devnull, 'w')
#with open('output.txt', 'w') as f:
#sys.stdout = io.BytesIO()
#sys.stdout.fileno() = os.devnull
#sys.stderr = f
#os.environ.update(dict(GRASS_VERBOSE='0'))
tmp_vect.close(build=False)
grass.run_command('v.build', map=tmp_map, quiet=True)
#os.environ.update(dict(GRASS_VERBOSE='1'))
#reg = Region()
#reg.read()
#r.from_vect(tmp_map)
r = align_current(r, buffer_geom[0].bbox())
r.write()
# Check if the following is needed
# needed specially with r.stats -p
#grass.run_command('g.region', vector=tmp_map, flags='a')
# Create a MASK from buffered geometry
if user_mask:
grass.run_command('v.to.rast', input=tmp_map,
output=tmp_map, use='val',
value=int(cat), quiet=True)
mc_expression = "MASK=if(!isnull({0}) && !isnull({0}_MASK), {1}, null())".format(tmp_map, cat)
grass.run_command('r.mapcalc', expression=mc_expression, quiet=True)
else:
grass.run_command('v.to.rast', input=tmp_map,
output='MASK', use='val',
value=int(cat), quiet=True)
#reg.write()
updates = []
# Compute statistics for every raster map
for rm in range(len(raster_maps)):
rmap = raster_maps[rm]
prefix = column_prefix[rm]
if tabulate:
# Get statistics on occurrence of raster categories within buffer
stats.inputs.input = rmap
stats.run()
t_stats = stats.outputs['stdout'].value.rstrip(os.linesep).replace(' ', '_b{} = '.format(b_str)).split(os.linesep)
if t_stats[0].split('_b{} = '.format(b_str))[0].split('_')[-1] != 'null':
mode = t_stats[0].split('_b{} = '.format(b_str))[0].split('_')[-1]
elif len(t_stats) == 1:
mode = 'NULL'
else:
mode = t_stats[1].split('_b{} = '.format(b_str))[0].split('_')[-1]
if not output:
updates.append('\t{}_{}_b{} = {}'.format(prefix, 'ncats', b_str, len(t_stats)))
updates.append('\t{}_{}_b{} = {}'.format(prefix, 'mode', b_str, mode))
area_tot = 0
for l in t_stats:
updates.append('\t{}_{}'.format(prefix, l.rstrip('%')))
if l.split('_b{} ='.format(b_str))[0].split('_')[-1] != 'null':
area_tot = area_tot + float(l.rstrip('%').split('= ')[1])
if not percent:
updates.append('\t{}_{}_b{} = {}'.format(prefix, 'area_tot', b_str, area_tot))
else:
out_str = '{1}{0}{2}{0}{3}{0}{4}{0}{5}{6}'.format(sep, cat, prefix, buf, 'ncats', len(t_stats), os.linesep)
out_str += '{1}{0}{2}{0}{3}{0}{4}{0}{5}{6}'.format(sep, cat, prefix, buf, 'mode', mode, os.linesep)
area_tot = 0
if not t_stats[0]:
grass.warning(empty_buffer_warning.format(rmap, buf, cat))
continue
for l in t_stats:
rcat = l.split('_b{} ='.format(b_str))[0].split('_')[-1]
area = l.split('= ')[1]
out_str += '{1}{0}{2}{0}{3}{0}{4}{0}{5}{6}'.format(sep, cat, prefix, buf, 'area {}'.format(rcat), area, os.linesep)
if rcat != 'null':
area_tot = area_tot + float(l.rstrip('%').split('= ')[1])
out_str += '{1}{0}{2}{0}{3}{0}{4}{0}{5}{6}'.format(sep, cat, prefix, buf, 'area_tot', area_tot, os.linesep)
if output == '-':
print(out_str.rstrip(os.linesep))
else:
out.write(out_str)
else:
# Get univariate statistics within buffer
univar.inputs.map = rmap
univar.run()
u_stats = univar.outputs['stdout'].value.rstrip(os.linesep).replace('=', '_b{} = '.format(b_str)).split(os.linesep)
# Test if u_stats is empty and give warning
# Needs to be adjusted to number of requested stats?
if (percentile and len(u_stats) < 14) or (univar.flags.e and len(u_stats) < 13) or len(u_stats) < 12:
grass.warning(empty_buffer_warning.format(rmap, buf, cat))
break
# Extract statistics for selected methods
for m in methods:
if not output:
# Add to list of UPDATE statements
updates.append('\t{}_{}'.format(prefix,
u_stats[int_dict[m][0]]))
else:
out_str = '{1}{0}{2}{0}{3}{0}{4}{0}{5}'.format(sep, cat, prefix, buf, m, u_stats[int_dict[m][0]].split('= ')[1])
if output == '-':
print(out_str)
else:
out.write("{}{}".format(out_str, os.linesep))
if percentile:
perc_count = 0
for perc in percentile:
if not output:
updates.append('{}_percentile_{}_b{} = {}'.format(p,
int(perc) if (perc).is_integer() else perc,
b_str, u_stats[15+perc_count].split('= ')[1]))
else:
out_str = '{1}{0}{2}{0}{3}{0}{4}{0}{5}'.format(sep, cat, prefix, buf, 'percentile_{}'.format(int(perc) if (perc).is_integer() else perc), u_stats[15+perc_count].split('= ')[1])
if output == '-':
print(out_str)
else:
out.write(out_str)
perc_count = perc_count + 1
if not output and len(updates) > 0:
cur.execute('{}{}{}'.format(sql_str_start,
',\n'.join(updates),
sql_str_end))
# Remove temporary maps
#, stderr=os.devnull, stdout_=os.devnull)
grass.run_command('g.remove', flags='f', type='raster',
name='MASK', quiet=True)
grass.run_command('g.remove', flags='f', type='vector',
name=tmp_map, quiet=True)
# Give progress information
grass.percent(n_geom, geoms_n, 1)
n_geom = n_geom + 1
if not output:
conn.commit()
# Close cursor and DB connection
if not output and not output == "-":
cur.close()
conn.close()
# Update history
grass.vector.vector_history(in_vector)
elif output != "-":
# write results to file
out.close()
if remove:
dropcols = []
selectnum = 'select count({}) from {}'
for i in col_names:
thisrow = grass.read_command('db.select', flags='c',
sql=selectnum.format(i, in_vector))
if int(thisrow) == 0:
dropcols.append(i)
grass.debug("Columns to delete: {}".format(', '.join(dropcols)),
debug=2)
grass.run_command('v.db.dropcolumn', map=in_vector, columns=dropcols)
