def put_region(self):
"""Set the remote region to the current region"""
region_name = gs.append_node_pid("g_remote_current")
# TODO: remove the region
gs.run_command("g.region", save=region_name, overwrite=True)
region_file = gs.find_file(region_name, element="windows")["file"]
remote_dir = "/".join([self.full_mapset, "windows"])
remote_file = "/".join([remote_dir, region_name])
# Check that the parent directory exists.
self.connection.run(f"ls {self.full_mapset}")
self.connection.run("mkdir -p {dir}".format(dir=remote_dir))
self.connection.put(region_file, remote_file)
result = self.run_command("g.region", region=region_name)
if result.returncode:
print(result.stderr, file=sys.stderr)
def _create_mapset(self, gisdbase, location, module):
"""Create mapset according to information in module.
:param loader.GrassTestPythonModule module:
"""
# TODO: use g.mapset -c, no need to duplicate functionality
# All path characters such as slash, backslash and dot are replaced.
dir_as_name = gs.legalize_vector_name(module.tested_dir,
fallback_prefix=None)
# Multiple processes can run the same test in the same location.
mapset = gs.append_node_pid(f"{dir_as_name}_{module.name}")
# TODO: use grass module to do this? but we are not in the right gisdbase
mapset_dir = os.path.join(gisdbase, location, mapset)
if self.clean_before:
silent_rmtree(mapset_dir)
os.mkdir(mapset_dir)
# TODO: default region in mapset will be what?
# copy DEFAULT_WIND file from PERMANENT to WIND
# TODO: this should be a function in grass.script (used also in gis_set.py, PyGRASS also has its way with Mapset)
shutil.copy(
os.path.join(gisdbase, location, "PERMANENT", "DEFAULT_WIND"),
os.path.join(mapset_dir, "WIND"),
)
return mapset, mapset_dir
def main():
global TMPLOC, SRCGISRC, GISDBASE, TMP_REG_NAME
GDALdatasource = options['input']
output = options['output']
method = options['resample']
memory = options['memory']
bands = options['band']
tgtres = options['resolution']
title = options["title"]
if flags['e'] and not output:
output = 'rimport_tmp' # will be removed with the entire tmp location
if options['resolution_value']:
if tgtres != 'value':
grass.fatal(
_("To set custom resolution value, select 'value' in resolution option"
))
tgtres_value = float(options['resolution_value'])
if tgtres_value <= 0:
grass.fatal(_("Resolution value can't be smaller than 0"))
elif tgtres == 'value':
grass.fatal(
_("Please provide the resolution for the imported dataset or change to 'estimated' resolution"
))
# try r.in.gdal directly first
additional_flags = 'l' if flags['l'] else ''
if flags['o']:
additional_flags += 'o'
region_flag = ''
if options['extent'] == 'region':
region_flag += 'r'
if flags['o'] or is_projection_matching(GDALdatasource):
parameters = dict(input=GDALdatasource,
output=output,
memory=memory,
flags='ak' + additional_flags + region_flag)
if bands:
parameters['band'] = bands
try:
grass.run_command('r.in.gdal', **parameters)
grass.verbose(
_("Input <%s> successfully imported without reprojection") %
GDALdatasource)
return 0
except CalledModuleError as e:
grass.fatal(
_("Unable to import GDAL dataset <%s>") % GDALdatasource)
grassenv = grass.gisenv()
tgtloc = grassenv['LOCATION_NAME']
# make sure target is not xy
if grass.parse_command('g.proj',
flags='g')['name'] == 'xy_location_unprojected':
grass.fatal(
_("Coordinate reference system not available for current location <%s>"
) % tgtloc)
tgtmapset = grassenv['MAPSET']
GISDBASE = grassenv['GISDBASE']
TMPLOC = grass.append_node_pid("tmp_r_import_location")
TMP_REG_NAME = grass.append_node_pid("tmp_r_import_region")
SRCGISRC, src_env = grass.create_environment(GISDBASE, TMPLOC, 'PERMANENT')
# create temp location from input without import
grass.verbose(
_("Creating temporary location for <%s>...") % GDALdatasource)
# creating a new location with r.in.gdal requires a sanitized env
env = os.environ.copy()
env = grass.sanitize_mapset_environment(env)
parameters = dict(input=GDALdatasource,
output=output,
memory=memory,
flags='c',
title=title,
location=TMPLOC,
quiet=True)
if bands:
parameters['band'] = bands
try:
grass.run_command('r.in.gdal', env=env, **parameters)
except CalledModuleError:
grass.fatal(_("Unable to read GDAL dataset <%s>") % GDALdatasource)
# prepare to set region in temp location
if 'r' in region_flag:
tgtregion = TMP_REG_NAME
grass.run_command('v.in.region', output=tgtregion, flags='d')
# switch to temp location
# print projection at verbose level
grass.verbose(
grass.read_command('g.proj', flags='p',
env=src_env).rstrip(os.linesep))
# make sure input is not xy
if grass.parse_command('g.proj', flags='g',
env=src_env)['name'] == 'xy_location_unprojected':
grass.fatal(
_("Coordinate reference system not available for input <%s>") %
GDALdatasource)
# import into temp location
grass.verbose(
_("Importing <%s> to temporary location...") % GDALdatasource)
parameters = dict(input=GDALdatasource,
output=output,
memory=memory,
flags='ak' + additional_flags)
if bands:
parameters['band'] = bands
if 'r' in region_flag:
grass.run_command('v.proj',
location=tgtloc,
mapset=tgtmapset,
input=tgtregion,
output=tgtregion,
env=src_env)
grass.run_command('g.region', vector=tgtregion, env=src_env)
parameters['flags'] = parameters['flags'] + region_flag
try:
grass.run_command('r.in.gdal', env=src_env, **parameters)
except CalledModuleError:
grass.fatal(_("Unable to import GDAL dataset <%s>") % GDALdatasource)
outfiles = grass.list_grouped('raster', env=src_env)['PERMANENT']
# is output a group?
group = False
path = os.path.join(GISDBASE, TMPLOC, 'group', output)
if os.path.exists(path):
group = True
path = os.path.join(GISDBASE, TMPLOC, 'group', output, 'POINTS')
if os.path.exists(path):
grass.fatal(_("Input contains GCPs, rectification is required"))
if 'r' in region_flag:
grass.run_command('g.remove',
type="vector",
flags="f",
name=tgtregion,
env=src_env)
# switch to target location
if 'r' in region_flag:
grass.run_command('g.remove', type="vector", flags="f", name=tgtregion)
region = grass.region()
rflags = None
if flags['n']:
rflags = 'n'
vreg = TMP_REG_NAME
for outfile in outfiles:
n = region['n']
s = region['s']
e = region['e']
w = region['w']
env = os.environ.copy()
if options['extent'] == 'input':
# r.proj -g
try:
tgtextents = grass.read_command('r.proj',
location=TMPLOC,
mapset='PERMANENT',
input=outfile,
flags='g',
memory=memory,
quiet=True)
except CalledModuleError:
grass.fatal(_("Unable to get reprojected map extent"))
try:
srcregion = grass.parse_key_val(tgtextents,
val_type=float,
vsep=' ')
n = srcregion['n']
s = srcregion['s']
e = srcregion['e']
w = srcregion['w']
except ValueError: # import into latlong, expect 53:39:06.894826N
srcregion = grass.parse_key_val(tgtextents, vsep=' ')
n = grass.float_or_dms(srcregion['n'][:-1]) * \
(-1 if srcregion['n'][-1] == 'S' else 1)
s = grass.float_or_dms(srcregion['s'][:-1]) * \
(-1 if srcregion['s'][-1] == 'S' else 1)
e = grass.float_or_dms(srcregion['e'][:-1]) * \
(-1 if srcregion['e'][-1] == 'W' else 1)
w = grass.float_or_dms(srcregion['w'][:-1]) * \
(-1 if srcregion['w'][-1] == 'W' else 1)
env['GRASS_REGION'] = grass.region_env(n=n, s=s, e=e, w=w)
# v.in.region in tgt
grass.run_command('v.in.region', output=vreg, quiet=True, env=env)
# reproject to src
# switch to temp location
try:
grass.run_command('v.proj',
input=vreg,
output=vreg,
location=tgtloc,
mapset=tgtmapset,
quiet=True,
env=src_env)
# test if v.proj created a valid area
if grass.vector_info_topo(vreg, env=src_env)['areas'] != 1:
grass.fatal(_("Please check the 'extent' parameter"))
except CalledModuleError:
grass.fatal(_("Unable to reproject to source location"))
# set region from region vector
grass.run_command('g.region', raster=outfile, env=src_env)
grass.run_command('g.region', vector=vreg, env=src_env)
# align to first band
grass.run_command('g.region', align=outfile, env=src_env)
# get number of cells
cells = grass.region(env=src_env)['cells']
estres = math.sqrt((n - s) * (e - w) / cells)
# remove from source location for multi bands import
grass.run_command('g.remove',
type='vector',
name=vreg,
flags='f',
quiet=True,
env=src_env)
# switch to target location
grass.run_command('g.remove',
type='vector',
name=vreg,
flags='f',
quiet=True)
grass.message(
_("Estimated target resolution for input band <{out}>: {res}").
format(out=outfile, res=estres))
if flags['e']:
continue
env = os.environ.copy()
if options['extent'] == 'input':
env['GRASS_REGION'] = grass.region_env(n=n, s=s, e=e, w=w)
res = None
if tgtres == 'estimated':
res = estres
elif tgtres == 'value':
res = tgtres_value
grass.message(
_("Using given resolution for input band <{out}>: {res}").
format(out=outfile, res=res))
# align to requested resolution
env['GRASS_REGION'] = grass.region_env(res=res, flags='a', env=env)
else:
curr_reg = grass.region()
grass.message(
_("Using current region resolution for input band "
"<{out}>: nsres={ns}, ewres={ew}").format(
out=outfile, ns=curr_reg['nsres'], ew=curr_reg['ewres']))
# r.proj
grass.message(_("Reprojecting <%s>...") % outfile)
try:
grass.run_command('r.proj',
location=TMPLOC,
mapset='PERMANENT',
input=outfile,
method=method,
resolution=res,
memory=memory,
flags=rflags,
quiet=True,
env=env)
except CalledModuleError:
grass.fatal(_("Unable to to reproject raster <%s>") % outfile)
if grass.raster_info(outfile)['min'] is None:
grass.fatal(_("The reprojected raster <%s> is empty") % outfile)
if flags['e']:
return 0
if group:
grass.run_command('i.group', group=output, input=','.join(outfiles))
# TODO: write metadata with r.support
return 0
def main():
global TMPLOC, SRCGISRC, TGTGISRC, GISDBASE
overwrite = grass.overwrite()
# list formats and exit
if flags['f']:
grass.run_command('v.in.ogr', flags='f')
return 0
# list layers and exit
if flags['l']:
try:
grass.run_command('v.in.ogr', flags='l', input=options['input'])
except CalledModuleError:
return 1
return 0
OGRdatasource = options['input']
output = options['output']
layers = options['layer']
vflags = ''
if options['extent'] == 'region':
vflags += 'r'
if flags['o']:
vflags += 'o'
vopts = {}
if options['encoding']:
vopts['encoding'] = options['encoding']
if options['datum_trans'] and options['datum_trans'] == '-1':
# list datum transform parameters
if not options['epsg']:
grass.fatal(_("Missing value for parameter <%s>") % 'epsg')
return grass.run_command('g.proj',
epsg=options['epsg'],
datum_trans=options['datum_trans'])
if layers:
vopts['layer'] = layers
if output:
vopts['output'] = output
vopts['snap'] = options['snap']
# try v.in.ogr directly
if flags['o'] or is_projection_matching(OGRdatasource):
try:
grass.run_command('v.in.ogr',
input=OGRdatasource,
flags=vflags,
overwrite=overwrite,
**vopts)
grass.message(
_("Input <%s> successfully imported without reprojection") %
OGRdatasource)
return 0
except CalledModuleError:
grass.fatal(_("Unable to import <%s>") % OGRdatasource)
grassenv = grass.gisenv()
tgtloc = grassenv['LOCATION_NAME']
# make sure target is not xy
if grass.parse_command('g.proj',
flags='g')['name'] == 'xy_location_unprojected':
grass.fatal(
_("Coordinate reference system not available for current location <%s>"
) % tgtloc)
tgtmapset = grassenv['MAPSET']
GISDBASE = grassenv['GISDBASE']
TGTGISRC = os.environ['GISRC']
SRCGISRC = grass.tempfile()
TMPLOC = grass.append_node_pid("tmp_v_import_location")
f = open(SRCGISRC, 'w')
f.write('MAPSET: PERMANENT\n')
f.write('GISDBASE: %s\n' % GISDBASE)
f.write('LOCATION_NAME: %s\n' % TMPLOC)
f.write('GUI: text\n')
f.close()
tgtsrs = grass.read_command('g.proj', flags='j', quiet=True)
# create temp location from input without import
grass.verbose(_("Creating temporary location for <%s>...") % OGRdatasource)
try:
if OGRdatasource.lower().endswith("gml"):
try:
from osgeo import gdal
except:
grass.fatal(
_("Unable to load GDAL Python bindings (requires package 'python-gdal' being installed)"
))
if int(gdal.VersionInfo('VERSION_NUM')) < GDAL_COMPUTE_VERSION(
2, 4, 1):
fix_gfsfile(OGRdatasource)
grass.run_command('v.in.ogr',
input=OGRdatasource,
location=TMPLOC,
flags='i',
quiet=True,
overwrite=overwrite,
**vopts)
except CalledModuleError:
grass.fatal(
_("Unable to create location from OGR datasource <%s>") %
OGRdatasource)
# switch to temp location
os.environ['GISRC'] = str(SRCGISRC)
if options['epsg']: # force given EPSG
kwargs = {}
if options['datum_trans']:
kwargs['datum_trans'] = options['datum_trans']
grass.run_command('g.proj', flags='c', epsg=options['epsg'], **kwargs)
# print projection at verbose level
grass.verbose(grass.read_command('g.proj', flags='p').rstrip(os.linesep))
# make sure input is not xy
if grass.parse_command('g.proj',
flags='g')['name'] == 'xy_location_unprojected':
grass.fatal(
_("Coordinate reference system not available for input <%s>") %
OGRdatasource)
if options['extent'] == 'region':
# switch to target location
os.environ['GISRC'] = str(TGTGISRC)
# v.in.region in tgt
vreg = grass.append_node_pid("tmp_v_import_region")
grass.run_command('v.in.region', output=vreg, quiet=True)
# reproject to src
# switch to temp location
os.environ['GISRC'] = str(SRCGISRC)
try:
grass.run_command('v.proj',
input=vreg,
output=vreg,
location=tgtloc,
mapset=tgtmapset,
quiet=True,
overwrite=overwrite)
except CalledModuleError:
grass.fatal(_("Unable to reproject to source location"))
# set region from region vector
grass.run_command('g.region', res='1')
grass.run_command('g.region', vector=vreg)
# import into temp location
grass.message(_("Importing <%s> ...") % OGRdatasource)
try:
if OGRdatasource.lower().endswith("gml"):
try:
from osgeo import gdal
except:
grass.fatal(
_("Unable to load GDAL Python bindings (requires package 'python-gdal' being installed)"
))
if int(gdal.VersionInfo('VERSION_NUM')) < GDAL_COMPUTE_VERSION(
2, 4, 1):
fix_gfsfile(OGRdatasource)
grass.run_command('v.in.ogr',
input=OGRdatasource,
flags=vflags,
overwrite=overwrite,
**vopts)
except CalledModuleError:
grass.fatal(_("Unable to import OGR datasource <%s>") % OGRdatasource)
# if output is not define check source mapset
if not output:
output = grass.list_grouped('vector')['PERMANENT'][0]
# switch to target location
os.environ['GISRC'] = str(TGTGISRC)
# check if map exists
if not grass.overwrite() and \
grass.find_file(output, element='vector', mapset='.')['mapset']:
grass.fatal(_("option <%s>: <%s> exists.") % ('output', output))
if options['extent'] == 'region':
grass.run_command('g.remove',
type='vector',
name=vreg,
flags='f',
quiet=True)
# v.proj
grass.message(_("Reprojecting <%s>...") % output)
try:
grass.run_command('v.proj',
location=TMPLOC,
mapset='PERMANENT',
input=output,
overwrite=overwrite)
except CalledModuleError:
grass.fatal(_("Unable to to reproject vector <%s>") % output)
return 0
def __init__(
self,
cmd,
width=None,
height=None,
overlap=0,
processes=None,
split=False,
debug=False,
region=None,
move=None,
log=False,
start_row=0,
start_col=0,
out_prefix="",
mapset_prefix=None,
*args,
**kargs,
):
kargs["run_"] = False
self.mset = Mapset()
self.module = Module(cmd, *args, **kargs)
self.width = width
self.height = height
self.overlap = overlap
self.processes = processes
self.region = region if region else Region()
self.start_row = start_row
self.start_col = start_col
self.out_prefix = out_prefix
self.log = log
self.move = move
self.gisrc_src = os.environ["GISRC"]
self.n_mset, self.gisrc_dst = None, None
if self.move:
self.n_mset = copy_mapset(self.mset, self.move)
self.gisrc_dst = write_gisrc(self.n_mset.gisdbase,
self.n_mset.location,
self.n_mset.name)
rasters = [r for r in select(self.module.inputs, "raster")]
if rasters:
copy_rasters(rasters,
self.gisrc_src,
self.gisrc_dst,
region=self.region)
vectors = [v for v in select(self.module.inputs, "vector")]
if vectors:
copy_vectors(vectors, self.gisrc_src, self.gisrc_dst)
groups = [g for g in select(self.module.inputs, "group")]
if groups:
copy_groups(groups,
self.gisrc_src,
self.gisrc_dst,
region=self.region)
self.bboxes = split_region_tiles(region=region,
width=width,
height=height,
overlap=overlap)
if mapset_prefix:
self.mapset_prefix = mapset_prefix
else:
self.mapset_prefix = append_node_pid("grid_" +
legalize_vector_name(cmd))
self.msetstr = self.mapset_prefix + "_%03d_%03d"
self.inlist = None
if split:
self.split()
self.debug = debug
def main():
global TMPLOC, SRCGISRC, GISDBASE, TMP_REG_NAME
GDALdatasource = options["input"]
output = options["output"]
method = options["resample"]
memory = options["memory"]
bands = options["band"]
tgtres = options["resolution"]
title = options["title"]
if flags["e"] and not output:
output = "rimport_tmp" # will be removed with the entire tmp location
if options["resolution_value"]:
if tgtres != "value":
grass.fatal(
_("To set custom resolution value, select 'value' in resolution option"
))
tgtres_value = float(options["resolution_value"])
if tgtres_value <= 0:
grass.fatal(_("Resolution value can't be smaller than 0"))
elif tgtres == "value":
grass.fatal(
_("Please provide the resolution for the imported dataset or change to 'estimated' resolution"
))
# try r.in.gdal directly first
additional_flags = "l" if flags["l"] else ""
if flags["o"]:
additional_flags += "o"
region_flag = ""
if options["extent"] == "region":
region_flag += "r"
if flags["o"] or is_projection_matching(GDALdatasource):
parameters = dict(
input=GDALdatasource,
output=output,
memory=memory,
flags="ak" + additional_flags + region_flag,
)
if bands:
parameters["band"] = bands
try:
grass.run_command("r.in.gdal", **parameters)
grass.verbose(
_("Input <%s> successfully imported without reprojection") %
GDALdatasource)
return 0
except CalledModuleError:
grass.fatal(
_("Unable to import GDAL dataset <%s>") % GDALdatasource)
grassenv = grass.gisenv()
tgtloc = grassenv["LOCATION_NAME"]
# make sure target is not xy
if grass.parse_command("g.proj",
flags="g")["name"] == "xy_location_unprojected":
grass.fatal(
_("Coordinate reference system not available for current location <%s>"
) % tgtloc)
tgtmapset = grassenv["MAPSET"]
GISDBASE = grassenv["GISDBASE"]
TMPLOC = grass.append_node_pid("tmp_r_import_location")
TMP_REG_NAME = grass.append_node_pid("tmp_r_import_region")
SRCGISRC, src_env = grass.create_environment(GISDBASE, TMPLOC, "PERMANENT")
# create temp location from input without import
grass.verbose(
_("Creating temporary location for <%s>...") % GDALdatasource)
# creating a new location with r.in.gdal requires a sanitized env
env = os.environ.copy()
env = grass.sanitize_mapset_environment(env)
parameters = dict(
input=GDALdatasource,
output=output,
memory=memory,
flags="c",
title=title,
location=TMPLOC,
quiet=True,
)
if bands:
parameters["band"] = bands
try:
grass.run_command("r.in.gdal", env=env, **parameters)
except CalledModuleError:
grass.fatal(_("Unable to read GDAL dataset <%s>") % GDALdatasource)
# prepare to set region in temp location
if "r" in region_flag:
tgtregion = TMP_REG_NAME
grass.run_command("v.in.region", output=tgtregion, flags="d")
# switch to temp location
# print projection at verbose level
grass.verbose(
grass.read_command("g.proj", flags="p",
env=src_env).rstrip(os.linesep))
# make sure input is not xy
if (grass.parse_command("g.proj", flags="g",
env=src_env)["name"] == "xy_location_unprojected"):
grass.fatal(
_("Coordinate reference system not available for input <%s>") %
GDALdatasource)
# import into temp location
grass.verbose(
_("Importing <%s> to temporary location...") % GDALdatasource)
parameters = dict(
input=GDALdatasource,
output=output,
memory=memory,
flags="ak" + additional_flags,
)
if bands:
parameters["band"] = bands
if "r" in region_flag:
grass.run_command(
"v.proj",
location=tgtloc,
mapset=tgtmapset,
input=tgtregion,
output=tgtregion,
env=src_env,
)
grass.run_command("g.region", vector=tgtregion, env=src_env)
parameters["flags"] = parameters["flags"] + region_flag
try:
grass.run_command("r.in.gdal", env=src_env, **parameters)
except CalledModuleError:
grass.fatal(_("Unable to import GDAL dataset <%s>") % GDALdatasource)
outfiles = grass.list_grouped("raster", env=src_env)["PERMANENT"]
# is output a group?
group = False
path = os.path.join(GISDBASE, TMPLOC, "group", output)
if os.path.exists(path):
group = True
path = os.path.join(GISDBASE, TMPLOC, "group", output, "POINTS")
if os.path.exists(path):
grass.fatal(_("Input contains GCPs, rectification is required"))
if "r" in region_flag:
grass.run_command("g.remove",
type="vector",
flags="f",
name=tgtregion,
env=src_env)
# switch to target location
if "r" in region_flag:
grass.run_command("g.remove", type="vector", flags="f", name=tgtregion)
region = grass.region()
rflags = None
if flags["n"]:
rflags = "n"
vreg = TMP_REG_NAME
for outfile in outfiles:
n = region["n"]
s = region["s"]
e = region["e"]
w = region["w"]
env = os.environ.copy()
if options["extent"] == "input":
# r.proj -g
try:
tgtextents = grass.read_command(
"r.proj",
location=TMPLOC,
mapset="PERMANENT",
input=outfile,
flags="g",
memory=memory,
quiet=True,
)
except CalledModuleError:
grass.fatal(_("Unable to get reprojected map extent"))
try:
srcregion = grass.parse_key_val(tgtextents,
val_type=float,
vsep=" ")
n = srcregion["n"]
s = srcregion["s"]
e = srcregion["e"]
w = srcregion["w"]
except ValueError: # import into latlong, expect 53:39:06.894826N
srcregion = grass.parse_key_val(tgtextents, vsep=" ")
n = grass.float_or_dms(srcregion["n"][:-1]) * (
-1 if srcregion["n"][-1] == "S" else 1)
s = grass.float_or_dms(srcregion["s"][:-1]) * (
-1 if srcregion["s"][-1] == "S" else 1)
e = grass.float_or_dms(srcregion["e"][:-1]) * (
-1 if srcregion["e"][-1] == "W" else 1)
w = grass.float_or_dms(srcregion["w"][:-1]) * (
-1 if srcregion["w"][-1] == "W" else 1)
env["GRASS_REGION"] = grass.region_env(n=n, s=s, e=e, w=w)
# v.in.region in tgt
grass.run_command("v.in.region", output=vreg, quiet=True, env=env)
# reproject to src
# switch to temp location
try:
grass.run_command(
"v.proj",
input=vreg,
output=vreg,
location=tgtloc,
mapset=tgtmapset,
quiet=True,
env=src_env,
)
# test if v.proj created a valid area
if grass.vector_info_topo(vreg, env=src_env)["areas"] != 1:
grass.fatal(_("Please check the 'extent' parameter"))
except CalledModuleError:
grass.fatal(_("Unable to reproject to source location"))
# set region from region vector
grass.run_command("g.region", raster=outfile, env=src_env)
grass.run_command("g.region", vector=vreg, env=src_env)
# align to first band
grass.run_command("g.region", align=outfile, env=src_env)
# get number of cells
cells = grass.region(env=src_env)["cells"]
estres = math.sqrt((n - s) * (e - w) / cells)
# remove from source location for multi bands import
grass.run_command("g.remove",
type="vector",
name=vreg,
flags="f",
quiet=True,
env=src_env)
# switch to target location
grass.run_command("g.remove",
type="vector",
name=vreg,
flags="f",
quiet=True)
grass.message(
_("Estimated target resolution for input band <{out}>: {res}").
format(out=outfile, res=estres))
if flags["e"]:
continue
env = os.environ.copy()
if options["extent"] == "input":
env["GRASS_REGION"] = grass.region_env(n=n, s=s, e=e, w=w)
res = None
if tgtres == "estimated":
res = estres
elif tgtres == "value":
res = tgtres_value
grass.message(
_("Using given resolution for input band <{out}>: {res}").
format(out=outfile, res=res))
# align to requested resolution
env["GRASS_REGION"] = grass.region_env(res=res, flags="a", env=env)
else:
curr_reg = grass.region()
grass.message(
_("Using current region resolution for input band "
"<{out}>: nsres={ns}, ewres={ew}").format(
out=outfile, ns=curr_reg["nsres"], ew=curr_reg["ewres"]))
# r.proj
grass.message(_("Reprojecting <%s>...") % outfile)
try:
grass.run_command(
"r.proj",
location=TMPLOC,
mapset="PERMANENT",
input=outfile,
method=method,
resolution=res,
memory=memory,
flags=rflags,
quiet=True,
env=env,
)
except CalledModuleError:
grass.fatal(_("Unable to to reproject raster <%s>") % outfile)
if grass.raster_info(outfile)["min"] is None:
grass.fatal(_("The reprojected raster <%s> is empty") % outfile)
if flags["e"]:
return 0
if group:
grass.run_command("i.group", group=output, input=",".join(outfiles))
# TODO: write metadata with r.support
return 0
def __init__(
self,
cmd,
width=None,
height=None,
overlap=0,
processes=None,
split=False,
debug=False,
region=None,
move=None,
log=False,
start_row=0,
start_col=0,
out_prefix="",
mapset_prefix=None,
patch_backend=None,
*args,
**kargs,
):
kargs["run_"] = False
self.mset = Mapset()
self.module = Module(cmd, *args, **kargs)
self.width = width
self.height = height
self.overlap = overlap
self.processes = processes
self.region = region if region else Region()
self.start_row = start_row
self.start_col = start_col
self.out_prefix = out_prefix
self.log = log
self.move = move
# by default RasterRow is used as previously
# if overlap > 0, r.patch won't work properly
if not patch_backend:
self.patch_backend = "RasterRow"
elif patch_backend not in ("r.patch", "RasterRow"):
raise RuntimeError(
_("Parameter patch_backend must be 'r.patch' or 'RasterRow'"))
elif patch_backend == "r.patch" and self.overlap:
raise RuntimeError(
_("Patching backend 'r.patch' doesn't work for overlap > 0"))
else:
self.patch_backend = patch_backend
self.gisrc_src = os.environ["GISRC"]
self.n_mset, self.gisrc_dst = None, None
self.estimate_tile_size()
if self.move:
self.n_mset = copy_mapset(self.mset, self.move)
self.gisrc_dst = write_gisrc(self.n_mset.gisdbase,
self.n_mset.location,
self.n_mset.name)
rasters = [r for r in select(self.module.inputs, "raster")]
if rasters:
copy_rasters(rasters,
self.gisrc_src,
self.gisrc_dst,
region=self.region)
vectors = [v for v in select(self.module.inputs, "vector")]
if vectors:
copy_vectors(vectors, self.gisrc_src, self.gisrc_dst)
groups = [g for g in select(self.module.inputs, "group")]
if groups:
copy_groups(groups,
self.gisrc_src,
self.gisrc_dst,
region=self.region)
self.bboxes = split_region_tiles(region=region,
width=self.width,
height=self.height,
overlap=overlap)
if mapset_prefix:
self.mapset_prefix = mapset_prefix
else:
self.mapset_prefix = append_node_pid("grid_" +
legalize_vector_name(cmd))
self.msetstr = self.mapset_prefix + "_%03d_%03d"
self.inlist = None
if split:
self.split()
self.debug = debug