def set_reference(descriptionflag = None): if options['raster_reference']: reference = options['raster_reference'] refname = reference elif options['vector_reference'] and options['column']: savedregion = grass.tempname(12) grass.run_command('g.region', save=savedregion) grass.run_command('g.region', raster=options['classification']) reference = grass.tempname(12) kwargs = { 'input': options['vector_reference'], 'output': reference, 'use': 'attr', 'attribute_column': options['column'] } if options['label_column']: kwargs['label_column'] = options['label_column'] grass.run_command('v.to.rast', quiet=True, **kwargs) refname = options['vector_reference'] + ' with column ' + options['column'] # reset region grass.run_command('g.region', region=savedregion, quiet=True) # remove region grass.run_command('g.remove', flags='f', type='region', name=savedregion, quiet=True) else: if not descriptionflag: grass.fatal("Either <raster_reference> or <vector_reference> and <column> must be indicated") return reference, refname
def set_reference(descriptionflag=None): if options["raster_reference"]: reference = options["raster_reference"] refname = reference elif options["vector_reference"] and options["column"]: savedregion = grass.tempname(12) grass.run_command("g.region", save=savedregion) grass.run_command("g.region", raster=options["classification"]) reference = grass.tempname(12) kwargs = { "input": options["vector_reference"], "output": reference, "use": "attr", "attribute_column": options["column"], } if options["label_column"]: kwargs["label_column"] = options["label_column"] grass.run_command("v.to.rast", quiet=True, **kwargs) refname = options["vector_reference"] + " with column " + options[ "column"] # reset region grass.run_command("g.region", region=savedregion, quiet=True) # remove region grass.run_command("g.remove", flags="f", type="region", name=savedregion, quiet=True) else: if not descriptionflag: grass.fatal( "Either <raster_reference> or <vector_reference> and <column> must be indicated" ) return reference, refname
def fill_band(bandmap, tilemask): '''Function to fill null pixels with interpolated values''' temporary_band = gscript.tempname(20) temporary_band2 = gscript.tempname(20) gscript.run_command('r.fill.stats', flags='k', input_=bandmap, output=temporary_band, distance=1, cells=2, overwrite=True, quiet=QUIET) null_test = gscript.read_command('r.stats', flags='N', input_=[tilemask,temporary_band], quiet=QUIET).splitlines() while '1 *' in null_test: gscript.run_command('r.fill.stats', flags='k', input_=temporary_band, output=temporary_band2, distance=1, cells=2, overwrite=True, quiet=QUIET) gscript.run_command('g.rename', raster=[temporary_band2, temporary_band], overwrite=True, quiet=QUIET) null_test = gscript.read_command('r.stats', flags='N', input_=[tilemask,temporary_band], quiet=QUIET).splitlines() filled_band = "%s_filled" % bandmap mapcalc_expression = "%s = round(%s)" % (filled_band, temporary_band) gscript.run_command('r.mapcalc', expression=mapcalc_expression, quiet=QUIET) gscript.run_command('g.remove', type='raster', name=temporary_band, flags='f', quiet=QUIET) return filled_band
import grass.script as grass from grass.pygrass.vector import VectorTopo from grass.pygrass.vector.basic import Bbox from grass.pygrass.raster.history import History from grass.pygrass.vector.geometry import Centroid from grass.pygrass.vector.geometry import Point from grass.pygrass.vector.geometry import Line from osgeo import ogr # check if GRASS is running or not if "GISBASE" not in os.environ: sys.exit("You must be in GRASS GIS to run this program") # Define additional variables # global TMP_PREFIX TMP_PREFIX = grass.tempname(12) def cleanup(): """Remove temporary data """ grass.del_temp_region() tmp_maps = grass.read_command("g.list", type=['vector', 'raster'], pattern='{}*'.format(TMP_PREFIX), separator=',') if tmp_maps: grass.run_command("g.remove", type=['vector', 'raster'], pattern='{}*'.format(TMP_PREFIX),
def main(): """Do the main work""" # Define static variables global tmpname tmpname = gscript.tempname(12) # Define user input variables a_flag = flags["a"] elevation = options["elevation"] direction = options["direction"] slope_measure = options["slope_measure"] outputs = options["output"].split(",") dir_format = options["dir_type"] try: steps = list(map(int, options["steps"].split(","))) except: gscript.fatal(_("Not all steps given as integer.")) n_steps = max(steps) abs = "abs" if a_flag else "" dir_values = gscript.parse_command("r.info", map=direction, flags="r") dir_type = check_directions(dir_format, float(dir_values["max"])) # Ceck if number of requested steps and outputs match if len(outputs) != len(steps): gscript.fatal(_("Number of steps and number of output maps differ")) # Define static variables kwargs_even = { "dir": direction, "elev_in": "{}_elev_even".format(tmpname), "elev_out": "{}_elev_odd".format(tmpname), } kwargs_odd = { "dir": direction, "elev_in": "{}_elev_odd".format(tmpname), "elev_out": "{}_elev_even".format(tmpname), } if slope_measure != "difference": kwargs_even["dist_in"] = "{}_dist_even".format(tmpname) kwargs_even["dist_out"] = "{}_dist_odd".format(tmpname) kwargs_even["dist_sum_in"] = "{}_dist_sum_even".format(tmpname) kwargs_even["dist_sum_out"] = "{}_dist_sum_odd".format(tmpname) kwargs_odd["dist_in"] = "{}_dist_odd".format(tmpname) kwargs_odd["dist_out"] = "{}_dist_even".format(tmpname) kwargs_odd["dist_sum_in"] = "{}_dist_sum_odd".format(tmpname) kwargs_odd["dist_sum_out"] = "{}_dist_sum_even".format(tmpname) dir_format_dict = { "degree_45": [1, 2, 3, 4, 5, 6, 7], "degree": [45, 90, 135, 180, 225, 270, 315], "bitmask": [1, 8, 7, 6, 5, 4, 3], } slope_measure_dict = { "difference": """\n{gradient}={abs}({elev}-{elev_in})""", "percent": """\n{gradient}={abs}({elev}-{elev_in})/{dist}""", "percent_int": """\n{gradient}=round(({abs}(({elev}-{elev_in}))/{dist})*10000.0)""", "degree": """\n{gradient}=atan({abs}({elev}-{elev_in})/{dist})""", "degree_int": """\n{gradient}=round(atan({abs}({elev}-{elev_in})/{dist})*100.0)""", } dirs = dir_format_dict[dir_type] expression_template = """{{elev_out}}=\ if({{dir}} == {0}, if(isnull({{elev_in}}[-1,1]),{{elev_in}},{{elev_in}}[-1,1]), \ if({{dir}} == {1}, if(isnull({{elev_in}}[-1,0]),{{elev_in}},{{elev_in}}[-1,0]), \ if({{dir}} == {2}, if(isnull({{elev_in}}[-1,-1]),{{elev_in}},{{elev_in}}[-1,-1]), \ if({{dir}} == {3}, if(isnull({{elev_in}}[0,-1]),{{elev_in}},{{elev_in}}[0,-1]), \ if({{dir}} == {4}, if(isnull({{elev_in}}[1,-1]),{{elev_in}},{{elev_in}}[1,-1]), \ if({{dir}} == {5}, if(isnull({{elev_in}}[1,0]),{{elev_in}},{{elev_in}}[1,0]), \ if({{dir}} == {6}, if(isnull({{elev_in}}[1,1]),{{elev_in}},{{elev_in}}[1,1]), \ if(isnull({{elev_in}}[0,1]),{{elev_in}},{{elev_in}}[0,1]))))))))""".format( *dirs ) kwargs = { "dir": direction, "elev_in": elevation, "elev_out": "{}_elev_even".format(tmpname), } if slope_measure != "difference": expression_template += """\n{{dist_out}}=\ if({{dir}} == {0}, if(isnull({{dist_in}}[-1,1]),{{dist_in}},{{dist_in}}[-1,1]), \ if({{dir}} == {1}, if(isnull({{dist_in}}[-1,0]),{{dist_in}},{{dist_in}}[-1,0]), \ if({{dir}} == {2}, if(isnull({{dist_in}}[-1,-1]),{{dist_in}},{{dist_in}}[-1,-1]), \ if({{dir}} == {3}, if(isnull({{dist_in}}[0,-1]),{{dist_in}},{{dist_in}}[0,-1]), \ if({{dir}} == {4}, if(isnull({{dist_in}}[1,-1]),{{dist_in}},{{dist_in}}[1,-1]), \ if({{dir}} == {5}, if(isnull({{dist_in}}[1,0]),{{dist_in}},{{dist_in}}[1,0]), \ if({{dir}} == {6}, if(isnull({{dist_in}}[1,1]),{{dist_in}},{{dist_in}}[1,1]), \ if(isnull({{dist_in}}[0,1]),{{dist_in}},{{dist_in}}[0,1])))))))) {{dist_sum_out}}={{dist_sum_in}}+{{dist_in}}""".format( *dirs ) kwargs["dist_in"] = "{}_dist_odd".format(tmpname) kwargs["dist_out"] = "{}_dist_even".format(tmpname) kwargs["dist_sum_in"] = "{}_dist_sum_odd".format(tmpname) kwargs["dist_sum_out"] = "{}_dist_sum_even".format(tmpname) # Start processing curent_region = gscript.region() gscript.run_command( "r.mapcalc", overwrite=True, quiet=True, expression="""{dist_in}=\ if({dir} == {NE} || {dir} == {NW} || {dir} == {SW}\ || {dir} == {SE}, sqrt({ewres}^2+{nsres}^2), \ if({dir} == {N} || {dir} == {S},{nsres},{ewres})) {dist_sum_in}=0""".format( NE=dirs[0], NW=dirs[2], SW=dirs[4], SE=dirs[6], N=dirs[1], S=dirs[5], nsres=curent_region["nsres"], ewres=curent_region["ewres"], dir=direction, dist_in=kwargs["dist_in"], dist_sum_in=kwargs["dist_sum_in"], ), ) for x in range(max(steps) + 1): mc_expression = expression_template.format(**kwargs) if x in steps: idx = steps.index(x) # Compile expression for r.mapcalc result_expression = slope_measure_dict[slope_measure] # Results are computed for output from previous step if slope_measure != "difference": result_kwargs = { "elev_in": kwargs["elev_in"], "elev": elevation, "dist": kwargs["dist_sum_in"], "abs": abs, "gradient": outputs[idx], } else: result_kwargs = { "elev_in": kwargs["elev_in"], "elev": elevation, "abs": abs, "gradient": outputs[idx], } result_expression = result_expression.format(**result_kwargs) if x == max(steps): mc_expression = result_expression.lstrip("\n") else: mc_expression += result_expression gscript.run_command( "r.mapcalc", overwrite=True, quiet=True, expression=mc_expression ) if x in steps: gscript.raster.raster_history(outputs[idx]) # Set variables for next iteration # Use even and odd numbers for iterative re-naming if x % 2 == 0: # Even kwargs = kwargs_even else: # Odd kwargs = kwargs_odd gscript.percent(x, max(steps), 1)
def main(): """Do the main work""" # Define static variables global tmpname tmpname = gscript.tempname(12) # Define user input variables a_flag = flags['a'] elevation = options['elevation'] direction = options['direction'] slope_measure = options['slope_measure'] outputs = options['output'].split(',') dir_format = options['dir_type'] try: steps = list(map(int, options['steps'].split(','))) except: gscript.fatal(_('Not all steps given as integer.')) n_steps = max(steps) abs = 'abs' if a_flag else '' dir_values = gscript.parse_command('r.info', map=direction, flags='r') dir_type = check_directions(dir_format, float(dir_values['max'])) # Ceck if number of requested steps and outputs match if len(outputs) != len(steps): gscript.fatal(_("Number of steps and number of output maps differ")) # Define static variables kwargs_even = { 'dir': direction, 'elev_in': '{}_elev_even'.format(tmpname), 'elev_out': '{}_elev_odd'.format(tmpname) } kwargs_odd = { 'dir': direction, 'elev_in': '{}_elev_odd'.format(tmpname), 'elev_out': '{}_elev_even'.format(tmpname) } if slope_measure != 'difference': kwargs_even['dist_in'] = '{}_dist_even'.format(tmpname) kwargs_even['dist_out'] = '{}_dist_odd'.format(tmpname) kwargs_even['dist_sum_in'] = '{}_dist_sum_even'.format(tmpname) kwargs_even['dist_sum_out'] = '{}_dist_sum_odd'.format(tmpname) kwargs_odd['dist_in'] = '{}_dist_odd'.format(tmpname) kwargs_odd['dist_out'] = '{}_dist_even'.format(tmpname) kwargs_odd['dist_sum_in'] = '{}_dist_sum_odd'.format(tmpname) kwargs_odd['dist_sum_out'] = '{}_dist_sum_even'.format(tmpname) dir_format_dict = { 'degree_45': [1, 2, 3, 4, 5, 6, 7], 'degree': [45, 90, 135, 180, 225, 270, 315], 'bitmask': [1, 8, 7, 6, 5, 4, 3] } slope_measure_dict = { 'difference': """\n{gradient}={abs}({elev}-{elev_in})""", 'percent': """\n{gradient}={abs}({elev}-{elev_in})/{dist}""", 'percent_int': """\n{gradient}=round(({abs}(({elev}-{elev_in}))/{dist})*10000.0)""", 'degree': """\n{gradient}=atan({abs}({elev}-{elev_in})/{dist})""", 'degree_int': """\n{gradient}=round(atan({abs}({elev}-{elev_in})/{dist})*100.0)""" } dirs = dir_format_dict[dir_type] expression_template = """{{elev_out}}=\ if({{dir}} == {0}, if(isnull({{elev_in}}[-1,1]),{{elev_in}},{{elev_in}}[-1,1]), \ if({{dir}} == {1}, if(isnull({{elev_in}}[-1,0]),{{elev_in}},{{elev_in}}[-1,0]), \ if({{dir}} == {2}, if(isnull({{elev_in}}[-1,-1]),{{elev_in}},{{elev_in}}[-1,-1]), \ if({{dir}} == {3}, if(isnull({{elev_in}}[0,-1]),{{elev_in}},{{elev_in}}[0,-1]), \ if({{dir}} == {4}, if(isnull({{elev_in}}[1,-1]),{{elev_in}},{{elev_in}}[1,-1]), \ if({{dir}} == {5}, if(isnull({{elev_in}}[1,0]),{{elev_in}},{{elev_in}}[1,0]), \ if({{dir}} == {6}, if(isnull({{elev_in}}[1,1]),{{elev_in}},{{elev_in}}[1,1]), \ if(isnull({{elev_in}}[0,1]),{{elev_in}},{{elev_in}}[0,1]))))))))""".format( *dirs) kwargs = { 'dir': direction, 'elev_in': elevation, 'elev_out': '{}_elev_even'.format(tmpname) } if slope_measure != 'difference': expression_template += """\n{{dist_out}}=\ if({{dir}} == {0}, if(isnull({{dist_in}}[-1,1]),{{dist_in}},{{dist_in}}[-1,1]), \ if({{dir}} == {1}, if(isnull({{dist_in}}[-1,0]),{{dist_in}},{{dist_in}}[-1,0]), \ if({{dir}} == {2}, if(isnull({{dist_in}}[-1,-1]),{{dist_in}},{{dist_in}}[-1,-1]), \ if({{dir}} == {3}, if(isnull({{dist_in}}[0,-1]),{{dist_in}},{{dist_in}}[0,-1]), \ if({{dir}} == {4}, if(isnull({{dist_in}}[1,-1]),{{dist_in}},{{dist_in}}[1,-1]), \ if({{dir}} == {5}, if(isnull({{dist_in}}[1,0]),{{dist_in}},{{dist_in}}[1,0]), \ if({{dir}} == {6}, if(isnull({{dist_in}}[1,1]),{{dist_in}},{{dist_in}}[1,1]), \ if(isnull({{dist_in}}[0,1]),{{dist_in}},{{dist_in}}[0,1])))))))) {{dist_sum_out}}={{dist_sum_in}}+{{dist_in}}""".format(*dirs) kwargs['dist_in'] = '{}_dist_odd'.format(tmpname) kwargs['dist_out'] = '{}_dist_even'.format(tmpname) kwargs['dist_sum_in'] = '{}_dist_sum_odd'.format(tmpname) kwargs['dist_sum_out'] = '{}_dist_sum_even'.format(tmpname) # Start processing curent_region = gscript.region() gscript.run_command('r.mapcalc', overwrite=True, quiet=True, expression="""{dist_in}=\ if({dir} == {NE} || {dir} == {NW} || {dir} == {SW}\ || {dir} == {SE}, sqrt({ewres}^2+{nsres}^2), \ if({dir} == {N} || {dir} == {S},{nsres},{ewres})) {dist_sum_in}=0""".format(NE=dirs[0], NW=dirs[2], SW=dirs[4], SE=dirs[6], N=dirs[1], S=dirs[5], nsres=curent_region['nsres'], ewres=curent_region['ewres'], dir=direction, dist_in=kwargs['dist_in'], dist_sum_in=kwargs['dist_sum_in'])) for x in range(max(steps) + 1): mc_expression = expression_template.format(**kwargs) if x in steps: idx = steps.index(x) # Compile expression for r.mapcalc result_expression = slope_measure_dict[slope_measure] # Results are computed for output from previous step if slope_measure != 'difference': result_kwargs = { 'elev_in': kwargs['elev_in'], 'elev': elevation, 'dist': kwargs['dist_sum_in'], 'abs': abs, 'gradient': outputs[idx] } else: result_kwargs = { 'elev_in': kwargs['elev_in'], 'elev': elevation, 'abs': abs, 'gradient': outputs[idx] } result_expression = result_expression.format(**result_kwargs) if x == max(steps): mc_expression = result_expression.lstrip('\n') else: mc_expression += result_expression gscript.run_command('r.mapcalc', overwrite=True, quiet=True, expression=mc_expression) if x in steps: gscript.raster.raster_history(outputs[idx]) # Set variables for next iteration # Use even and odd numbers for iterative re-naming if x % 2 == 0: # Even kwargs = kwargs_even else: # Odd kwargs = kwargs_odd gscript.percent(x, max(steps), 1)
def main(): # options and flags options, flags = gs.parser() input_raster = options["input"] minradius = int(options["minradius"]) maxradius = int(options["maxradius"]) steps = int(options["steps"]) output_raster = options["output"] region = Region() res = np.mean([region.nsres, region.ewres]) # some checks if "@" in output_raster: output_raster = output_raster.split("@")[0] if maxradius <= minradius: gs.fatal("maxradius must be greater than minradius") if steps < 2: gs.fatal("steps must be greater than 1") # calculate radi for generalization radi = np.logspace(np.log(minradius), np.log(maxradius), steps, base=np.exp(1), dtype=np.int) radi = np.unique(radi) sizes = radi * 2 + 1 # multiscale calculation ztpi_maps = list() for step, (radius, size) in enumerate(zip(radi[::-1], sizes[::-1])): gs.message( "Calculating the TPI at radius {radius}".format(radius=radius)) # generalize the dem step_res = res * size step_res_pretty = str(step_res).replace(".", "_") generalized_dem = gs.tempname(4) if size > 15: step_dem = gs.tempname(4) gg.region(res=str(step_res)) gr.resamp_stats( input=input_raster, output=step_dem, method="average", flags="w", ) gr.resamp_rst( input=step_dem, ew_res=res, ns_res=res, elevation=generalized_dem, quiet=True, ) region.write() gg.remove(type="raster", name=step_dem, flags="f", quiet=True) else: gr.neighbors(input=input_raster, output=generalized_dem, size=size) # calculate the tpi tpi = gs.tempname(4) gr.mapcalc(expression="{x} = {a} - {b}".format( x=tpi, a=input_raster, b=generalized_dem)) gg.remove(type="raster", name=generalized_dem, flags="f", quiet=True) # standardize the tpi raster_stats = gr.univar(map=tpi, flags="g", stdout_=PIPE).outputs.stdout raster_stats = parse_key_val(raster_stats) tpi_mean = float(raster_stats["mean"]) tpi_std = float(raster_stats["stddev"]) ztpi = gs.tempname(4) ztpi_maps.append(ztpi) RAST_REMOVE.append(ztpi) gr.mapcalc(expression="{x} = ({a} - {mean})/{std}".format( x=ztpi, a=tpi, mean=tpi_mean, std=tpi_std)) gg.remove(type="raster", name=tpi, flags="f", quiet=True) # integrate if step > 1: tpi_updated2 = gs.tempname(4) gr.mapcalc("{x} = if(abs({a}) > abs({b}), {a}, {b})".format( a=ztpi_maps[step], b=tpi_updated1, x=tpi_updated2)) RAST_REMOVE.append(tpi_updated2) tpi_updated1 = tpi_updated2 else: tpi_updated1 = ztpi_maps[0] RAST_REMOVE.pop() gg.rename(raster=(tpi_updated2, output_raster), quiet=True) # set color theme with RasterRow(output_raster) as src: color_rules = """{minv} blue -1 0:34:198 0 255:255:255 1 255:0:0 {maxv} 110:15:0 """ color_rules = color_rules.format(minv=src.info.min, maxv=src.info.max) gr.colors(map=output_raster, rules="-", stdin_=color_rules, quiet=True)
def tmpname(): """Generate a tmp name and stores it in the global list.""" tmpf = gs.tempname(12) clean_layers.append(tmpf) return tmpf
import itertools from grass.pygrass.gis import Mapset from grass.pygrass.raster import RasterRow from grass.pygrass.raster import raster2numpy from grass.pygrass.raster import numpy2raster from grass.pygrass.gis.region import Region from grass.pygrass.vector.basic import Bbox import grass.script as grass from grass.script import utils as grassutils # Declare global variables # random name of binary viewshed TEMPNAME = grass.tempname(12) def cleanup(): """Remove raster and vector maps stored in a list""" grass.run_command( "g.remove", flags="f", type="raster,vector", pattern="{}_*".format(TEMPNAME), quiet=True, stderr=subprocess.PIPE, ) # Reset mask if user MASK was present if (RasterRow("MASK",
# %rules # % required: alias_input,env_maps # % exclusive: alias_input,alias_output # % requires: alias_output,alias_names # % requires: species_names,species_masks # % requires: species_output,species_masks # %end import atexit import os import grass.script as gscript from grass.pygrass.gis import Mapset from grass.pygrass.raster import RasterRow TMP_NAME = gscript.tempname(12) def cleanup(): """Restore old mask if it existed""" if RasterRow("{}_MASK".format(TMP_NAME), Mapset().name).exist(): gscript.verbose("Restoring old mask...") if RasterRow("MASK", Mapset().name).exist(): gscript.run_command("r.mask", flags="r") gscript.run_command( "g.rename", rast="{}_MASK,MASK".format(TMP_NAME), quiet=True ) if RasterRow("MASK", Mapset().name).exist(): gscript.run_command("r.mask", flags="r")
class TestFunctions(TestCase): """The main (and only) test case for the r.viewshed.exposure module""" tempname = gs.tempname(12) # Raster maps used as inputs source_roads = "roadsmajor@PERMANENT" source_lakes = "lakes@PERMANENT" source_points = "geodetic_swwake_pts@PERMANENT" dsm = "elevation@PERMANENT" functions = [ "Binary", "Fuzzy_viewshed", "Distance_decay", "Solid_angle", "Visual_magnitude", ] r_viewshed = SimpleModule( "r.viewshed.exposure", flags="cr", input=dsm, source=source_roads, observer_elevation=1.5, range=100, b1_distance=10, sample_density=5, seed=50, memory=5000, nprocs=10, quiet=True, overwrite=True, ) test_results_stats = { "test_roads_B": { "n": 120880, "null_cells": 1904120, "cells": 2025000, "min": 0, "max": 15, "range": 15, "mean": 1.62403, "mean_of_abs": 1.62403, "stddev": 1.93013, "variance": 3.72542, "coeff_var": 118.848259976884, "sum": 196313, }, "test_roads_F": { "n": 120880, "null_cells": 1904120, "cells": 2025000, "min": 0, "max": 11.3565, "range": 11.3565, "mean": 1.20334, "mean_of_abs": 1.20334, "stddev": 1.47689, "variance": 2.18121, "coeff_var": 122.732631198116, "sum": 145459.99071890, }, "test_roads_D": { "n": 120880, "null_cells": 1904120, "cells": 2025000, "min": 0, "max": 3.86, "range": 3.86, "mean": 0.118786, "mean_of_abs": 0.118786, "stddev": 0.275875, "variance": 0.076107, "coeff_var": 232.246, "sum": 14358.8130874699, }, "test_roads_S": { "n": 120749, "null_cells": 1904251, "cells": 2025000, "min": 0, "max": 3.00867, "range": 3.00867, "mean": 0.0232121, "mean_of_abs": 0.0232121, "stddev": 0.202763, "variance": 0.0411129, "coeff_var": 873.523497082485, "sum": 2802.8384487502, }, "test_roads_V": { "n": 120749, "null_cells": 1904251, "cells": 2025000, "min": 0, "max": 45.2416, "range": 45.2416, "mean": 0.34082, "mean_of_abs": 0.34082, "stddev": 3.80045, "variance": 14.4434, "coeff_var": 1115.09106861343, "sum": 41153.6541857501, }, "test_lakes": { "n": 75396, "null_cells": 1949604, "cells": 2025000, "min": 0, "max": 4.61498, "range": 4.61498, "mean": 0.422226, "mean_of_abs": 0.422226, "stddev": 0.555438, "variance": 0.308511, "coeff_var": 131.549853569661, "sum": 31834.1479829689, }, "test_points": { "n": 97340, "null_cells": 1927660, "cells": 2025000, "min": 0, "max": 11.8462, "range": 11.8462, "mean": 0.0432476, "mean_of_abs": 0.0432476, "stddev": 0.144737, "variance": 0.0209488, "coeff_var": 334.675522436311, "sum": 4209.66482665949, }, } @classmethod def setUpClass(cls): """Setup temp region.""" # Save current region to temporary file gs.use_temp_region() gs.run_command("g.region", raster=cls.dsm, align=cls.dsm) @classmethod def tearDownClass(cls): """Reset original region and remove the temporary region""" gs.del_temp_region() def tearDown(self): """Remove the output created from the module This is executed after each test function run. If we had something to set up before each test function run, we would use setUp() function. Since we remove the raster map after running each test function, we can reuse the same name for all the test functions. """ self.runModule("g.remove", flags="f", type="raster", pattern="test_2*") def test_roads(self): """Test exposure to roads using all viewshed parametrisation functions""" # Use the input DSM to set computational region gs.run_command("g.region", raster=self.dsm, align=self.dsm) for function in self.functions: # Output dataset output = "test_roads_{}".format(function[0]) self.r_viewshed.outputs.output = output # Input datasets self.r_viewshed.inputs.input = self.dsm self.r_viewshed.inputs.source = self.source_roads self.r_viewshed.inputs.function = function self.r_viewshed.inputs.sampling_points = None # # Print the command # print(self.r_viewshed.get_bash()) # Check that the module runs self.assertModule(self.r_viewshed) # Check to see if output is in mapset self.assertRasterExists(output, msg="Output was not created") # Here we need to check if univariate raster statistics match the expected result self.assertRasterFitsUnivar( raster=output, reference=self.test_results_stats[output], precision=1e-4, ) def test_lakes(self): """Test exposure to lakes.""" # Use the input DSM to set computational region gs.run_command("g.region", raster=self.dsm, align=self.dsm) function = "Distance_decay" # Output dataset output = "test_lakes" self.r_viewshed.outputs.output = output # Input dataset self.r_viewshed.inputs.input = self.dsm self.r_viewshed.inputs.source = self.source_lakes self.r_viewshed.inputs.function = function # # Print the command # print(self.r_viewshed.get_bash()) # Check that the module runs self.assertModule(self.r_viewshed) # Check to see if output is in mapset self.assertRasterExists(output, msg="Output was not created") # Here we need to check if univariate raster statistics match the expected result self.assertRasterFitsUnivar( raster=output, reference=self.test_results_stats[output], precision=1e-5, ) def test_points(self): """Test exposure from points""" # Use of of the input dsm to set computational region gs.run_command("g.region", raster=self.dsm, align=self.dsm) function = "Distance_decay" # Output datasets output = "test_points" self.r_viewshed.outputs.output = output # Input datasets self.r_viewshed.inputs.input = self.dsm self.r_viewshed.inputs.source = None self.r_viewshed.inputs.sampling_points = self.source_points self.r_viewshed.inputs.function = function # # Print command # print(self.r_viewshed.get_bash()) # Check that the module runs self.assertModule(self.r_viewshed) # Check to see if output is in mapset self.assertRasterExists(output, msg="Output was not created") # Here we need to check if univariate raster statistics match the expected result self.assertRasterFitsUnivar( raster=output, reference=self.test_results_stats[output], precision=1e-4, )