def main():
host = options['host']
port = options['port']
database = options['database']
schema = options['schema']
user = options['user']
password = options['password']
# Test connection
conn = "dbname=" + database
if host: conn += ",host=" + host
if port: conn += ",port=" + port
# Unfortunately we cannot test untill user/password is set
if user or password:
print "Setting login (db.login) ... "
sys.stdout.flush()
if grass.run_command('db.login', driver = "pg", database = conn, user = user, password = password) != 0:
grass.fatal("Cannot login")
# Try to connect
print "Testing connection ..."
sys.stdout.flush()
if grass.run_command('db.select', quiet = True, flags='c', driver= "pg", database=conn, sql="select version()" ) != 0:
if user or password:
print "Deleting login (db.login) ..."
sys.stdout.flush()
if grass.run_command('db.login', quiet = True, driver = "pg", database = conn, user = "", password = "") != 0:
print "Cannot delete login."
sys.stdout.flush()
grass.fatal("Cannot connect to database.")
if grass.run_command('db.connect', driver = "pg", database = conn, schema = schema) != 0:
grass.fatal("Cannot connect to database.")
def main():
mon = grass.gisenv().get('MONITOR', None)
if not mon:
grass.fatal(_("No graphics device selected. Use d.mon to select graphics device."))
monCmd = grass.parse_command('d.mon', flags='g').get('cmd', None)
if not monCmd or not os.path.isfile(monCmd):
grass.fatal(_("Unable to open file '%s'") % monCmd)
try:
fd = open(monCmd, 'r')
cmdList = fd.readlines()
grass.run_command('d.erase')
for cmd in cmdList:
grass.call(split(cmd))
except IOError as e:
grass.fatal(_("Unable to open file '%s' for reading. Details: %s") %
(monCmd, e))
fd.close()
# restore cmd file
try:
fd = open(monCmd, "w")
fd.writelines(cmdList)
except IOError as e:
grass.fatal(_("Unable to open file '%s' for writing. Details: %s") %
(monCmd, e))
return 0
def main():
env = grass.gisenv()
mapset = env['MAPSET']
ret = 0
vectors = grass.list_grouped('vect')[mapset]
num_vectors = len(vectors)
if grass.verbosity() < 2:
quiet = True
else:
quiet = False
i = 1
for vect in vectors:
map = "%s@%s" % (vect, mapset)
grass.message(_("%s\nBuilding topology for vector map <%s> (%d of %d)...\n%s") % \
('-' * 80, map, i, num_vectors, '-' * 80))
grass.verbose(_("v.build map=%s") % map)
try:
grass.run_command("v.build", map=map, quiet=quiet)
except CalledModuleError:
grass.error(_("Building topology for vector map <%s> failed") % map)
ret = 1
i += 1
return ret
def draw_linegraph(what):
yfiles = []
xfile = os.path.join(tmp_dir, 'data_x')
xf = open(xfile, 'w')
for j, val in enumerate(what[0][3:]):
xf.write("%d\n" % (j + 1))
xf.close()
for i, row in enumerate(what):
yfile = os.path.join(tmp_dir, 'data_y_%d' % i)
yf = open(yfile, 'w')
for j, val in enumerate(row[3:]):
yf.write("%s\n" % val)
yf.close()
yfiles.append(yfile)
sienna = '#%02x%02x%02x' % (160, 82, 45)
coral = '#%02x%02x%02x' % (255, 127, 80)
gp_colors = ['red', 'green', 'blue', 'magenta', 'cyan', sienna, 'orange',
coral]
colors = gp_colors
while len(what) > len(colors):
colors += gp_colors
colors = colors[0:len(what)]
grass.run_command('d.linegraph', x_file=xfile, y_file=yfiles,
y_color=colors, title='Spectral signatures',
x_title='Bands', y_title='DN Value')
def generate_points(name, probability_map, count, overwrite=False):
gcore.run_command('v.random.probability', output=name, probability=probability_map,
count=count, overwrite=overwrite)
gcore.run_command('v.db.addtable', map=name,
columns="xshift double precision,"
"yshift double precision,"
"t integer")
def main():
"""Main function, called at execution time"""
# parse arguments
input = options['input']
var = options['var']
prefix = options['prefix']
# read NetCDF data
nc = Dataset(input, 'r')
data = nc.variables[var][:]
nc.close()
# set temporary region
res = 32463.0
rows = 277
cols = 349
grass.run_command('g.region',
n=res*(rows-0.5), s=res*-0.5,
e=res*(cols-0.5), w=res*-0.5,
rows=rows, cols=cols)
# for each month
a = garray.array()
for (i, timeslice) in enumerate(data):
mapname = prefix + '%02i' % (i+1)
grass.message("Importing <%s> ..." % mapname)
# import data with grass array
a[:] = flipud(timeslice)
a.write(mapname=mapname, overwrite=True, null=-32767)
def CleanUp(self, restore=True):
"""
:param restore: if restore previous cursor, mouse['use']
"""
try:
gcore.run_command('g.remove', type='rast', flags='f', name=self._backupRasterName, quiet=True)
except CalledModuleError:
pass
self._mapWindow.ClearLines(pdc=self._mapWindow.pdcTmp)
self._mapWindow.mouse['end'] = self._mapWindow.mouse['begin']
# disconnect mouse events
if self._graphicsType:
self._disconnectAll()
# unregister
self._mapWindow.UnregisterGraphicsToDraw(self._areas)
self._mapWindow.UnregisterGraphicsToDraw(self._lines)
self._mapWindow.UnregisterGraphicsToDraw(self._points)
#self._registeredGraphics = None
self._mapWindow.UpdateMap(render=False)
if restore:
# restore mouse['use'] and cursor to the state before measuring starts
self._mapWindow.SetNamedCursor(self._oldCursor)
self._mapWindow.mouse['use'] = self._oldMouseUse
def polylines(points_map, output, env):
"""Cluster points and connect points by line in each cluster"""
tmp_cluster = 'tmp_cluster'
gcore.run_command('v.cluster', flags='t', input=points_map, min=3, layer='3', output=tmp_cluster, method='optics', env=env)
cats = gcore.read_command('v.category', input=tmp_cluster, layer=3, option='print', env=env).strip()
cats = list(set(cats.split()))
line = ''
for cat in cats:
point_list = []
distances = {}
points = gcore.read_command('v.out.ascii', input=tmp_cluster, layer=3,
type='point', cats=cat, format='point', env=env).strip().split()
for point in points:
point = point.split('|')[:2]
point_list.append((float(point[0]), float(point[1])))
for i, point1 in enumerate(point_list[:-1]):
for point2 in point_list[i + 1:]:
distances[(point1, point2)] = sqrt((point1[0] - point2[0]) * (point1[0] - point2[0]) +
(point1[1] - point2[1]) * (point1[1] - point2[1]))
ordered = sorted(distances.items(), key=lambda x: x[1])[:len(points) - 1]
for key, value in ordered:
line += 'L 2 1\n'
line += '{x} {y}\n'.format(x=key[0][0], y=key[0][1])
line += '{x} {y}\n'.format(x=key[1][0], y=key[1][1])
line += '1 {cat}\n\n'.format(cat=cat)
gcore.write_command('v.in.ascii', input='-', stdin=line, output=output, format='standard', flags='n', env=env)
gcore.run_command('v.to.rast', input=output, output=output, type='line', use='cat', env=env)
def main():
env = grass.gisenv()
mon = env.get('MONITOR', None)
if not mon:
grass.fatal(_("No monitor selected. Run `d.mon` to select monitor."))
monCmd = env.get('MONITOR_%s_CMDFILE' % mon.upper())
if not monCmd:
grass.fatal(_("No cmd file found for monitor <%s>") % mon)
try:
fd = open(monCmd, 'r')
cmdList = fd.readlines()
grass.run_command('d.erase')
for cmd in cmdList:
grass.call(split(cmd))
except IOError as e:
grass.fatal(_("Unable to open file '%s' for reading. Details: %s") % \
(monCmd, e))
fd.close()
# restore cmd file
try:
fd = open(monCmd, "w")
fd.writelines(cmdList)
except IOError as e:
grass.fatal(_("Unable to open file '%s' for writing. Details: %s") % \
(monCmd, e))
return 0
def cleanup():
if len(TMP_RAST + TMP_VECT):
gcore.info(_("Cleaning %d temporary maps...") % len(TMP_RAST + TMP_VECT))
gcore.run_command('g.remove', rast=','.join(TMP_RAST), quiet=True)
gcore.run_command('g.remove', vect=','.join(TMP_VECT), quiet=True)
gcore.del_temp_region()
def main():
"""Main function, called at execution time"""
# parse arguments
inputfile = options['input']
outputmap = options['output']
var = options['var']
# read NetCDF data
nc = Dataset(inputfile, 'r')
lon = nc.variables['longitude'][:]
lat = nc.variables['latitude'][:]
z = nc.variables[var][:]
nc.close()
# check that coordinates are regular
dlon = np.diff(lon)
dlat = np.diff(lat)
dlon0 = dlon[0]
dlat0 = dlat[0]
assert (dlon == dlon0).all()
assert (dlat == dlat0).all()
# crop illegal latitudes
lat = lat[np.abs(lat) < 90-np.abs(dlat0)/2]
# rotate longitudes and sort
lon -= (lon > 180)*360
lon_args = lon.argsort()
lat_args = lat.argsort()[::-1]
# crop and rotate data
lat = lat[lat_args]
lon = lon[lon_args]
z = z[:, lat_args, :][:, :, lon_args]
# set temporary region
w = lon[-1] + dlon0/2
e = lon[0] - dlon0/2
s = lat[-1] - dlat0/2
n = lat[0] + dlat0/2
rows = len(lat)
cols = len(lon)
grass.run_command('g.region', w=w, e=e, s=s, n=n, rows=rows, cols=cols)
# import time-independent data as such
a = garray.array()
if z.shape[0] == 1:
a[:] = z[0]
grass.message("Importing <%s> ..." % outputmap)
a.write(mapname=outputmap, overwrite=True, null=-32767)
# otherwise import each time slice
else:
for (i, data) in enumerate(z):
mapname = outputmap + '%02i' % (i+1)
grass.message("Importing <%s> ..." % mapname)
a[:] = data
a.write(mapname=mapname, overwrite=True, null=-32767)
def setColor(mapa):
grass.run_command('v.colors',
map=mapa,
use='attr',
layer=2,
column='precip_mm_h',
rules=options['color']
)
def trail(scanned_elev, friction, walk_coeff, _lambda, slope_factor,
walk, walk_dir, point_from, points_to, raster_route, vector_routes, env):
gcore.run_command('r.walk',overwrite=True, flags='k', elevation=scanned_elev,
friction=friction, output=walk, start_coordinates=point_from, outdir=walk_dir,
stop_coordinates=points_to, walk_coeff=walk_coeff, _lambda=_lambda, slope_factor=slope_factor, env=env)
for i in range(len(points_to)):
gcore.run_command('r.drain', overwrite=True, input=walk, direction=walk_dir, flags='d', drain=vector_routes[i],
output=raster_route, start_coordinates=points_to[i], env=env)
def trail_salesman(trails, points, output, env):
net_tmp = 'net_tmp'
gcore.run_command('v.net', input=trails, points=points, output=net_tmp,
operation='connect', threshold=10, overwrite=True, env=env)
cats = gcore.read_command('v.category', input=net_tmp, layer=2,
option='print', env=env).strip().split(os.linesep)
gcore.run_command('v.net.salesman', input=net_tmp, output=output,
ccats=','.join(cats), alayer=1, nlayer=2, overwrite=True, env=env)
def subsurface_borehole(points, voxel, new, size, offset, axes, unit, env):
coordinates = gcore.read_command('v.out.ascii', input=points, format='point', separator=',', env=env).strip()
coords_list = []
for coords in coordinates.split(os.linesep):
coords_list.extend(coords.split(',')[:2])
gcore.run_command('r3.borehole', overwrite=True, input=voxel, output=new,
coordinates=','.join(coords_list), size=size, offset_size=offset, axes=axes, unit=unit, env=env)
def render(cmd, mapfile):
env = os.environ.copy()
if mapfile:
env['GRASS_RENDER_FILE'] = mapfile
try:
grass.run_command(cmd[0], env=env, **cmd[1])
except Exception as e:
grass.debug(1, "Unable to render: {}".format(e))
def writeCircle(self, circle, rasterName):
coords = self.mapWindow.Pixel2Cell(circle.point)
RunCommand('r.circle', output=rasterName, max=circle.radius,
coordinate=coords, flags="b")
grass.use_temp_region()
grass.run_command('g.region', zoom=rasterName)
region = grass.region()
marea = MaskedArea(region, rasterName, circle.radius)
return marea
def _backupRaster(self, name):
name = name.split('@')[0]
backup = name + '_backupcopy_' + str(os.getpid())
try:
gcore.run_command('g.copy', rast=[name, backup], quiet=True)
except CalledModuleError:
raise ScriptError
self._backupRasterName = backup
def OnOK(self, event):
"""Button 'OK' pressed"""
mapsets = ','.join(self.GetMapsets())
grass.run_command('g.mapsets',
quiet = True,
mapset = mapsets)
self.Close()
def copy(existingmap, newmap, maptype, **kwargs):
"""Copy a map
>>> copy('census', 'mycensus', 'vect')
>>> rename('mycensus', 'mynewcensus', 'vect')
>>> remove('mynewcensus', 'vect')
"""
kwargs.update({maptype: '{old},{new}'.format(old=existingmap, new=newmap)})
grasscore.run_command('g.copy', quiet=True, **kwargs)
def main():
input = options['input']
layer = options['layer']
format = options['format']
output = options['output']
table = options['table']
if format.lower() == 'dbf':
format = "ESRI_Shapefile"
if format.lower() == 'csv':
olayer = basename(output, 'csv')
else:
olayer = None
#is there a simpler way of testing for --overwrite?
dbffile = input + '.dbf'
if os.path.exists(dbffile) and not grass.overwrite():
grass.fatal(_("File <%s> already exists") % dbffile)
if olayer:
try:
grass.run_command('v.out.ogr', quiet=True, input=input, layer=layer,
output=output,
format=format, type='point,line,area',
olayer=olayer)
except CalledModuleError:
grass.fatal(_("Module <%s> failed") % 'v.out.ogr')
else:
try:
grass.run_command('v.out.ogr', quiet=True, input=input,
layer=layer, output=output,
format=format, type='point,line,area')
except CalledModuleError:
grass.fatal(_("Module <%s> failed") % 'v.out.ogr')
if format == "ESRI_Shapefile":
exts = ['shp', 'shx', 'prj']
if output.endswith('.dbf'):
outname = basename(output, 'dbf')
for ext in exts:
try_remove("%s.%s" % (outname, ext))
outname += '.dbf'
else:
for ext in exts:
try_remove(os.path.join(output, "%s.%s" % (input, ext)))
outname = os.path.join(output, input + ".dbf")
elif format.lower() == 'csv':
outname = output + '.csv'
else:
outname = input
grass.message(_("Exported table <%s>") % outname)
def rlake(scanned_elev, new, base, env, seed, level, **kwargs):
suffix = str(uuid.uuid4()).replace('-', '')[:5]
match = 'tmp_match' + suffix
params = {}
if isinstance(seed, list):
params['coordinates'] = ','.join(str(each) for each in seed)
else:
params['seed'] = seed
match_scan(base=base, scan=scanned_elev, matched=match, env=env)
gcore.run_command('r.lake', elevation=match, water_level=level, lake=new, env=env, **params)
gcore.run_command('g.remove', flags='f', type='raster', name=[match])
def erase(monitor):
# remove frames
lines = []
for line in read_monitor_file(monitor):
if 'FRAME' not in line:
lines.append(line)
write_monitor_file(monitor, lines)
# erase screen
run_command('d.erase')
def registerPid(pid):
"""Register process id as GUI_PID GRASS variable
:param: pid process id
"""
env = grass.gisenv()
guiPid = []
if 'GUI_PID' in env:
guiPid = env['GUI_PID'].split(',')
guiPid.append(str(pid))
grass.run_command('g.gisenv', set='GUI_PID={}'.format(','.join(guiPid)))
def main():
options, unused = gcore.parser()
drape_map = options['color']
relief_map = options['shade']
brighten = options['brighten']
try:
gcore.run_command('d.his', hue=drape_map, intensity=relief_map,
brighten=brighten)
except CalledModuleError:
gcore.fatal(_("Module %s failed. Check the above error messages.") % 'd.his')
def depression(scanned_elev, new, env, filter_depth=0, repeat=2):
"""Run r.fill.dir to compute depressions"""
suffix = str(uuid.uuid4()).replace('-', '')[:5]
input_dem = scanned_elev
output = "tmp_filldir" + suffix
tmp_dir = "tmp_dir" + suffix
for i in range(repeat):
gcore.run_command('r.fill.dir', input=input_dem, output=output, direction=tmp_dir, env=env)
input_dem = output
grast.mapcalc('{new} = if({out} - {scan} > {depth}, {out} - {scan}, null())'.format(new=new, out=output, scan=scanned_elev, depth=filter_depth), env=env)
gcore.write_command('r.colors', map=new, rules='-', stdin='0% aqua\n100% blue', env=env)
gcore.run_command('g.remove', flags='f', type='raster', name=[output, tmp_dir], env=env)
def _backupRaster(self, name):
"""Creates a temporary backup raster necessary for undo behavior.
:param str name: name of raster map for which we create backup
"""
name = name.split('@')[0]
backup = name + '_backupcopy_' + str(os.getpid())
try:
gcore.run_command('g.copy', raster=[name, backup], quiet=True)
except CalledModuleError:
raise ScriptError
self._backupRasterName = backup
def viewshed(scanned_elev, output, vector, visible_color, invisible_color, obs_elev=1.7, env=None):
coordinates = gcore.read_command('v.out.ascii', input=vector, separator=',', env=env).strip()
coordinate = None
for line in coordinates.split(os.linesep):
try:
coordinate = [float(c) for c in line.split(',')[0:2]]
except ValueError: # no points in map
pass
break
if coordinate:
gcore.run_command('r.viewshed', flags='b', input=scanned_elev, output=output, coordinates=coordinate, observer_elevation=obs_elev, env=env)
gcore.run_command('r.null', map=output, null=0, env=env)
gcore.write_command('r.colors', map=output, rules='-', stdin='0 {invis}\n1 {vis}'.format(vis=visible_color, invis=invisible_color), env=env)
def main():
options, flags = gcore.parser()
probability = options['probability']
output = options['output']
count = int(options['count'])
gcore.use_temp_region()
# probability map
probab_01 = 'probability_01_' + str(os.getpid())
TMP_RAST.append(probab_01)
info = grast.raster_info(probability)
gcore.write_command('r.recode', flags='d', input=probability, output=probab_01,
title="Recoded probability map to 0 to 1",
rules='-', stdin='{minim}:{maxim}:0:1'.format(minim=info['min'], maxim=info['max']))
mean = gcore.parse_key_val(gcore.read_command('r.univar', map=probab_01, flags='g'),
val_type=float)['mean']
resolution = count / (mean * (info['north'] - info['south'] + info['east'] - info['west']))
resolution = sqrt((mean * (info['north'] - info['south']) * (info['east'] - info['west'])) / count)
gcore.run_command('g.region', res=resolution)
random_name = 'random_' + str(os.getpid())
point_map = 'points_' + str(os.getpid())
point_grid = 'points_' + str(os.getpid())
TMP_RAST.append(random_name)
TMP_RAST.append(point_map)
TMP_VECT.append(point_grid)
gcore.run_command('r.surf.random', output=random_name, min=0, max=1)
grast.mapcalc(exp='{point_map} = if({rand} <= {prob}, 1, null())'.format(rand=random_name,
prob=probab_01,
point_map=point_map))
gcore.run_command('r.to.vect', flags='t', input=point_map, output=point_grid, type='point')
gcore.run_command('v.perturb', input=point_grid, output=output,
parameter=resolution / 2., seed=os.getpid())
def main():
# see https://grasswiki.osgeo.org/wiki/Convert_all_GRASS_6_vector_maps_to_GRASS_7
grass.message('Building topology')
if grass.run_command('v.build.all') != 0:
grass.warning('Cannot build topology')
grass.message('Creating new DB connection')
if grass.run_command('db.connect', flags='d') != 0:
grass.warning('Cannot create new DB connection')
return
grass.message('Transferring tables to the new DB')
if grass.run_command('v.db.reconnect.all', flags='cd') != 0:
grass.warning('Cannot transfer tables')
def main():
input = options['input']
layer = options['layer']
format = options['format']
output = options['output']
table = options['table']
if format.lower() == 'dbf':
format = "ESRI_Shapefile"
if format.lower() == 'csv':
olayer = basename(output, 'csv')
else:
olayer = None
# is there a simpler way of testing for --overwrite?
dbffile = input + '.dbf'
if os.path.exists(dbffile) and not gcore.overwrite():
gcore.fatal(_("File <%s> already exists") % dbffile)
if olayer:
try:
gcore.run_command('v.out.ogr',
quiet=True,
input=input,
layer=layer,
output=output,
format=format,
type='point,line,area',
olayer=olayer)
except CalledModuleError:
gcore.fatal(_("Module <%s> failed") % 'v.out.ogr')
else:
try:
gcore.run_command('v.out.ogr',
quiet=True,
input=input,
layer=layer,
output=output,
format=format,
type='point,line,area')
except CalledModuleError:
gcore.fatal(_("Module <%s> failed") % 'v.out.ogr')
if format == "ESRI_Shapefile":
exts = ['shp', 'shx', 'prj']
if output.endswith('.dbf'):
outname = basename(output, 'dbf')
for ext in exts:
try_remove("%s.%s" % (outname, ext))
outname += '.dbf'
else:
for ext in exts:
try_remove(os.path.join(output, "%s.%s" % (input, ext)))
outname = os.path.join(output, input + ".dbf")
elif format.lower() == 'csv':
outname = output + '.csv'
else:
outname = input
gcore.message(_("Exported table <%s>") % outname)
def slope(scanned_elev, new, env, zfactor=1.):
gcore.run_command('r.slope.aspect', elevation=scanned_elev, zfactor=zfactor, slope=new, overwrite=True, env=env)
def shaded_relief(scanned_elev, new, zmult=10, env=None):
gcore.run_command('r.shaded.relief', overwrite=True, input=scanned_elev, output=new, zmult=zmult, env=env)
def max_curv(scanned_elev, new, size=15, zscale=5, env=None):
gcore.run_command('r.param.scale', overwrite=True, input=scanned_elev, output=new, size=size, param='maxic', zscale=zscale, env=env)
gcore.run_command('r.colors', map=new, color='byr', env=env)
def geomorphon(scanned_elev, new, search=22, skip=12, flat=1, dist=0, env=None):
gcore.run_command('r.geomorphon', overwrite=True, dem=scanned_elev, forms=new, search=search, skip=skip, flat=flat, dist=dist, env=env)
def rename(oldname, newname, maptype, **kwargs):
"""Rename a map"""
kwargs.update({maptype: '{old},{new}'.format(old=oldname, new=newname), })
grasscore.run_command('g.rename', quiet=True, **kwargs)
streams.write(l, cat=10, attrs=(10,))
streams.organization = 'Thuenen Institut'
streams.person = 'Soeren Gebbert'
streams.title = 'Test dataset for stream networks'
streams.comment = 'This is a comment'
streams.table.conn.commit()
streams.close()
if __name__ == "__main__":
import doctest
from grass.pygrass import utils
from grass.script.core import run_command
utils.create_test_vector_map(test_vector_name)
run_command("g.region", n=50, s=0, e=60, w=0, res=1)
run_command("r.mapcalc", expression="%s = 1"%(test_raster_name),
overwrite=True)
doctest.testmod()
"""Remove the generated vector map, if exist"""
mset = utils.get_mapset_vector(test_vector_name, mapset='')
if mset:
run_command("g.remove", flags='f', type='vector', name=test_vector_name)
mset = utils.get_mapset_raster(test_raster_name, mapset='')
if mset:
run_command("g.remove", flags='f', type='raster', name=test_raster_name)
def main():
global tmp
global sine_cosine_replic, outercircle, vector
global totalvalidnumber, totalnumber, maxradius
map = options['map']
undef = options['undef']
eps = options['output']
xgraph = flags['x']
tmp = grass.tempfile()
if eps and xgraph:
grass.fatal(_("Please select only one output method"))
#### check if we have xgraph (if no EPS output requested)
if xgraph and not grass.find_program('xgraph'):
grass.fatal(
_("xgraph required, please install first (www.xgraph.org)"))
#################################
# this file contains everthing:
rawfile = tmp + "_raw"
rawf = file(rawfile, 'w')
grass.run_command('r.stats', flags='1', input=map, stdout=rawf)
rawf.close()
rawf = file(rawfile)
totalnumber = 0
for line in rawf:
totalnumber += 1
rawf.close()
grass.message(
_("Calculating statistics for polar diagram... (be patient)"))
#wipe out NULL data and undef data if defined by user
# - generate degree binned to integer, eliminate NO DATA (NULL):
# change 360 to 0 to close polar diagram:
rawf = file(rawfile)
nvals = 0
sumcos = 0
sumsin = 0
freq = {}
for line in rawf:
line = line.rstrip('\r\n')
if line in ['*', undef]:
continue
nvals += 1
x = float(line)
rx = math.radians(x)
sumcos += math.cos(rx)
sumsin += math.sin(rx)
ix = round(x)
if ix == 360:
ix = 0
if ix in freq:
freq[ix] += 1
else:
freq[ix] = 1
rawf.close()
totalvalidnumber = nvals
if totalvalidnumber == 0:
grass.fatal(_("No data pixel found"))
#################################
# unit vector on raw data converted to radians without no data:
unitvector = (sumcos / nvals, sumsin / nvals)
#################################
# how many are there?:
occurrences = [(math.radians(x), freq[x]) for x in freq]
occurrences.sort()
# find the maximum value
maxradius = max([f for a, f in occurrences])
# now do cos() sin()
sine_cosine = [(math.cos(a) * f, math.sin(a) * f) for a, f in occurrences]
sine_cosine_replic = ['"Real data angles'] + sine_cosine + sine_cosine[0:1]
if eps or xgraph:
outercircle = []
outercircle.append('"All Data incl. NULLs')
scale = 1.0 * totalnumber / totalvalidnumber * maxradius
for i in range(0, 361):
a = math.radians(i)
x = math.cos(a) * scale
y = math.sin(a) * scale
outercircle.append((x, y))
# fix vector length to become visible (x? of $MAXRADIUS):
vector = []
vector.append('"Avg. Direction\n')
vector.append((0, 0))
vector.append((unitvector[0] * maxradius, unitvector[1] * maxradius))
###########################################################
# Now output:
if eps:
psout = basename(eps, 'eps') + '.eps'
plot_eps(psout)
elif xgraph:
plot_xgraph()
else:
plot_dgraph()
grass.message(_("Average vector:"))
grass.message(
_("direction: %.1f degrees CCW from East") %
math.degrees(math.atan2(unitvector[1], unitvector[0])))
grass.message(
_("magnitude: %.1f percent of fullscale") %
(100 * math.hypot(unitvector[0], unitvector[1])))
def _set_grass(self, wps_request):
"""Handle given grass_location parameter of the constructor
location is either directory name, 'epsg:1234' form or a georeferenced
file
in the first case, new temporary mapset within the location will be
created
in the second case, location will be created in self.workdir
the mapset should be deleted automatically using self.clean() method
"""
if not PY2:
LOGGER.warning('Seems PyWPS is running in Python-3 '
'environment, but GRASS GIS supports Python-2 only')
return
if self.grass_location:
import random
import string
from grass.script import core as grass
from grass.script import setup as gsetup
# HOME needs to be set - and that is usually not the case for httpd
# server
os.environ['HOME'] = self.workdir
# GISRC envvariable needs to be set
gisrc = open(os.path.join(self.workdir, 'GISRC'), 'w')
gisrc.write("GISDBASE: {}\n".format(self.workdir))
gisrc.write("GUI: txt\n")
gisrc.close()
os.environ['GISRC'] = gisrc.name
new_loc_args = dict()
mapset_name = 'pywps_ms_{}'.format(''.join(
random.sample(string.ascii_letters, 5)))
if self.grass_location.startswith('complexinput:'):
# create new location from a georeferenced file
ref_file_parameter = self.grass_location.split(':')[1]
ref_file = wps_request.inputs[ref_file_parameter][0].file
new_loc_args.update({'filename': ref_file})
elif self.grass_location.lower().startswith('epsg:'):
# create new location from epsg code
epsg = self.grass_location.lower().replace('epsg:', '')
new_loc_args.update({'epsg': epsg})
if new_loc_args:
dbase = self.workdir
location = str()
while os.path.isdir(os.path.join(dbase, location)):
location = 'pywps_loc_{}'.format(''.join(
random.sample(string.ascii_letters, 5)))
gsetup.init(self.workdir, dbase, location, 'PERMANENT')
grass.create_location(dbase=dbase,
location=location,
**new_loc_args)
LOGGER.debug('GRASS location based on {} created'.format(
list(new_loc_args.keys())[0]))
grass.run_command('g.mapset',
mapset=mapset_name,
flags='c',
dbase=dbase,
location=location)
# create temporary mapset within existing location
elif os.path.isdir(self.grass_location):
from grass.pygrass.gis import make_mapset
LOGGER.debug('Temporary mapset will be created')
dbase = os.path.dirname(self.grass_location)
location = os.path.basename(self.grass_location)
grass.run_command('g.gisenv', set="GISDBASE={}".format(dbase))
grass.run_command('g.gisenv',
set="LOCATION_NAME=%s" % location)
while os.path.isdir(os.path.join(dbase, location,
mapset_name)):
mapset_name = 'pywps_ms_{}'.format(''.join(
random.sample(string.ascii_letters, 5)))
make_mapset(mapset=mapset_name,
location=location,
gisdbase=dbase)
grass.run_command('g.gisenv', set="MAPSET=%s" % mapset_name)
else:
raise NoApplicableCode(
'Location does exists or does not seem '
'to be in "EPSG:XXXX" form nor is it existing directory: {}'
.format(location))
# set _grass_mapset attribute - will be deleted once handler ends
self._grass_mapset = mapset_name
# final initialization
LOGGER.debug('GRASS Mapset set to {}'.format(mapset_name))
LOGGER.debug('GRASS environment initialised')
LOGGER.debug(
'GISRC {}, GISBASE {}, GISDBASE {}, LOCATION {}, MAPSET {}'.
format(os.environ.get('GISRC'), os.environ.get('GISBASE'),
dbase, location, os.path.basename(mapset_name)))
def main(opts, flgs):
ow = overwrite()
output = opts["output_basename"]
forest = opts["forest"]
boundaries = opts["boundaries"]
yield_ = opts["forest_column_yield"]
management = opts["forest_column_management"]
treatment = opts["forest_column_treatment"]
yield_surface = opts["forest_column_yield_surface"]
roughness = opts["forest_column_roughness"]
forest_roads = opts["forest_roads"]
rivers = opts["rivers"]
lakes = opts["lakes"]
vector_forest = opts["forest"]
tech_bioenergyHF = output + "_tech_bioenergyHF"
tech_bioenergyC = output + "_tech_bioenergyC"
tech_bioenergy = output + "_tech_bioenergy"
######## start import and convert ########
run_command("g.region", vect=boundaries)
run_command(
"v.to.rast",
input=forest,
output="yield",
use="attr",
attrcolumn=yield_,
overwrite=True,
)
run_command(
"v.to.rast",
input=forest,
output="yield_surface",
use="attr",
attrcolumn=yield_surface,
overwrite=True,
)
run_command(
"v.to.rast",
input=forest,
output="treatment",
use="attr",
attrcolumn=treatment,
overwrite=True,
)
run_command(
"v.to.rast",
input=forest,
output="management",
use="attr",
attrcolumn=management,
overwrite=True,
)
run_command(
"v.to.rast",
input=forest_roads,
output="forest_roads",
use="val",
overwrite=True,
)
run_command("r.null", map="yield", null=0)
run_command("r.null", map="yield_surface", null=0)
run_command("r.null", map="treatment", null=0)
run_command("r.null", map="management", null=0)
######## end import and convert ########
######## temp patch to link map and fields ######
management = "management"
treatment = "treatment"
yield_surface = "yield_surface"
yield_ = "yield"
forest_roads = "forest_roads"
######## end temp patch to link map and fields ######
if roughness == "":
run_command("r.mapcalc", overwrite=ow, expression="roughness=0")
roughness = "roughness"
else:
run_command(
"v.to.rast",
input=forest,
output="roughness",
use="attr",
attrcolumn=roughness,
overwrite=True,
)
run_command("r.null", map="roughness", null=0)
CCEXTR = ("cable_crane_extraction = if(" + yield_ + ">0 && slope>" +
opts["slp_min_cc"] + " && slope<=" + opts["slp_max_cc"] +
" && extr_dist<" + opts["dist_max_cc"] + ", 1)")
FWEXTR = ("forwarder_extraction = if(" + yield_ + ">0 && slope<=" +
opts["slp_max_fw"] + " && " + management + "==1 && (" +
roughness + "==0 || " + roughness + "==1 || " + roughness +
"==99999) && extr_dist<" + opts["dist_max_fw"] + ", 1)")
OEXTR = ("other_extraction = if(" + yield_ + ">0 && slope<=" +
opts["slp_max_cop"] + " && " + management + "==2 && (" +
roughness + "==0 || " + roughness + "==1 || " + roughness +
"==99999) && extr_dist<" + opts["dist_max_cop"] + ", 1)")
EHF = (tech_bioenergyHF + " = technical_surface*(if(" + management +
"==1 && " + treatment + "==1 || " + management + "==1 && " +
treatment + "==99999, yield_pix*" + opts["energy_tops_hf"] +
", if(" + management + "==1 && " + treatment + "==2, yield_pix *" +
opts["energy_tops_hf"] + " + yield_pix * " +
opts["energy_cormometric_vol_hf"] + ")))")
ECC = (tech_bioenergyC + " = technical_surface*(if(" + management +
" == 2, yield_pix*" + opts["energy_tops_cop"] + "))")
ET = tech_bioenergy + " = (" + tech_bioenergyC + " + " + tech_bioenergyHF + ")"
run_command(
"r.param.scale",
overwrite=ow,
input=opts["dtm"],
output="morphometric_features",
size=3,
method="feature",
)
run_command("r.slope.aspect",
overwrite=ow,
elevation=opts["dtm"],
slope="slope_deg")
run_command(
"r.mapcalc",
overwrite=ow,
expression="pix_cross = ((ewres()+nsres())/2)/ cos(slope_deg)",
)
run_command(
"r.mapcalc",
overwrite=ow,
expression="yield_pix1 = (" + yield_ + "/" + yield_surface +
")*((ewres()*nsres())/10000)",
)
run_command("r.null", map="yield_pix1", null=0)
run_command("r.null", map="morphometric_features", null=0)
exprmap = "frict_surf_extr = pix_cross + if(yield_pix1<=0, 99999) + if(morphometric_features==6, 99999)"
if rivers != "":
run_command("v.to.rast",
input=rivers,
output="rivers",
use="val",
overwrite=True)
run_command("r.null", map="rivers", null=0)
rivers = "rivers"
exprmap += "+ if(" + rivers + ">=1, 99999)"
if lakes != "":
run_command("v.to.rast",
input=lakes,
output="lakes",
use="val",
overwrite=True)
run_command("r.null", map="lakes", null=0)
lakes = "lakes"
exprmap += "+ if(" + lakes + ">=1, 99999)"
# morphometric_features==6 -> peaks
# run_command("r.mapcalc", overwrite=ow,expression='frict_surf_extr = if(morphometric_features==6, 99999) + if(rivers>=1 || lakes>=1, 99999) + if(yield_pix1<=0, 99999) + pix_cross')
run_command("r.mapcalc", overwrite=ow, expression=exprmap)
run_command(
"r.cost",
overwrite=ow,
input="frict_surf_extr",
output="extr_dist",
stop_points=vector_forest,
start_rast=forest_roads,
max_cost=1500,
)
run_command(
"r.slope.aspect",
overwrite=ow,
elevation=opts["dtm"],
slope="slope",
format="percent",
)
run_command("r.mapcalc", overwrite=ow, expression=CCEXTR)
run_command("r.mapcalc", overwrite=ow, expression=FWEXTR)
run_command("r.mapcalc", overwrite=ow, expression=OEXTR)
run_command("r.null", map="cable_crane_extraction", null=0)
run_command("r.null", map="forwarder_extraction", null=0)
run_command("r.null", map="other_extraction", null=0)
run_command(
"r.mapcalc",
overwrite=ow,
expression=
"technical_surface = cable_crane_extraction + forwarder_extraction + other_extraction",
)
# run_command("r.statistics", overwrite=ow,
# base="compartment", cover="technical_surface", method="sum",
# output="techn_pix_comp")
# run_command("r.mapcalc", overwrite=ow,
# expression='yield_pix2 = yield/(technical_surface*@techn_pix_comp)')
# run_command("r.null", map="yield_pix2", null=0)
# run_command("r.mapcalc", overwrite=ow,
# expression=YPIX % (1 if flgs['u'] else 0, 0 if flgs['u'] else 1,))
run_command("r.mapcalc", overwrite=ow, expression="yield_pix=yield_pix1")
run_command("r.mapcalc", overwrite=ow, expression=EHF)
run_command("r.mapcalc", overwrite=ow, expression=ECC)
run_command("r.mapcalc", overwrite=ow, expression=ET)
with RasterRow(tech_bioenergy) as pT:
T = np.array(pT)
print("Resulted maps: " + output + "_tech_bioenergyHF, " + output +
"_tech_bioenergyC, " + output + "_tech_bioenergy")
print("Total bioenergy stimated (Mwh): %.2f" % np.nansum(T))
if flgs["r"]:
remove_map(opts, flgs)
def createVect(view_nat):
grass.run_command('v.in.ogr',
input="PG:",
layer=layer,
output=ogr,
overwrite=True,
flags='t',
key=key,
type=typ,
quiet=True)
# if vector already exits, remove dblink (original table)
if grass.find_file(view_nat, element='vector')['fullname']:
grass.run_command('v.db.connect',
map=view_nat,
flags='d',
layer='1',
quiet=True)
grass.run_command('v.db.connect',
map=view_nat,
flags='d',
layer='2',
quiet=True)
grass.run_command('v.category',
input=ogr,
output=view_nat,
option="transfer",
overwrite=True,
layer="1,2",
quiet=True)
grass.run_command('v.db.connect',
map=view_nat,
table=layer,
key=key,
layer='1',
quiet=True)
grass.run_command('v.db.connect',
map=view_nat,
table=view,
key=key,
layer='2',
quiet=True)
if options['color']:
setColor(view_nat)
def main():
infile = options['input']
output = options['output']
method = options['method']
dtype = options['type']
fs = options['separator']
x = options['x']
y = options['y']
z = options['z']
value_column = options['value_column']
vrange = options['vrange']
vscale = options['vscale']
percent = options['percent']
pth = options['pth']
trim = options['trim']
workers = int(options['workers'])
scan_only = flags['s']
shell_style = flags['g']
ignore_broken = flags['i']
if workers is 1 and "WORKERS" in os.environ:
workers = int(os.environ["WORKERS"])
if not os.path.exists(infile):
grass.fatal(_("Unable to read input file <%s>") % infile)
addl_opts = {}
if pth:
addl_opts['pth'] = '%s' % pth
if trim:
addl_opts['trim'] = '%s' % trim
if value_column:
addl_opts['value_column'] = '%s' % value_column
if vrange:
addl_opts['vrange'] = '%s' % vrange
if vscale:
addl_opts['vscale'] = '%s' % vscale
if ignore_broken:
addl_opts['flags'] = 'i'
if scan_only or shell_style:
if shell_style:
doShell = 'g'
else:
doShell = ''
grass.run_command('r.in.xyz', flags='s' + doShell, input=infile,
output='dummy', sep=fs, x=x, y=y, z=z,
**addl_opts)
sys.exit()
if dtype == 'float':
data_type = 'FCELL'
else:
data_type = 'DCELL'
region = grass.region(region3d=True)
if region['nsres'] != region['nsres3'] or region['ewres'] != region['ewres3']:
grass.run_command('g.region', flags='3p')
grass.fatal(_("The 2D and 3D region settings are different. Can not continue."))
grass.verbose(_("Region bottom=%.15g top=%.15g vertical_cell_res=%.15g (%d depths)")
% (region['b'], region['t'], region['tbres'], region['depths']))
grass.verbose(_("Creating slices ..."))
# to avoid a point which falls exactly on a top bound from being
# considered twice, we shrink the
# For the top slice we keep it though, as someone scanning the bounds
# may have set the bounds exactly to the data extent (a bad idea, but
# it happens..)
eps = 1.0e-15
# if there are thousands of depths hopefully this array doesn't get too
# large and so we don't have to worry much about storing/looping through
# all the finished process infos.
proc = {}
pout = {}
depths = range(1, 1 + region['depths'])
for i in depths:
tmp_layer_name = 'tmp.r3xyz.%d.%s' % (os.getpid(), '%05d' % i)
zrange_min = region['b'] + (region['tbres'] * (i - 1))
if i < region['depths']:
zrange_max = region['b'] + (region['tbres'] * i) - eps
else:
zrange_max = region['b'] + (region['tbres'] * i)
# spawn depth layer import job in the background
#grass.debug("slice %d, <%s> %% %d" % (band, image[band], band % workers))
grass.message(_("Processing horizontal slice %d of %d [%.15g,%.15g) ...")
% (i, region['depths'], zrange_min, zrange_max))
proc[i] = grass.start_command('r.in.xyz', input=infile, output=tmp_layer_name,
sep=fs, method=method, x=x, y=y, z=z,
percent=percent, type=data_type,
zrange='%.15g,%.15g' % (zrange_min, zrange_max),
**addl_opts)
grass.debug("i=%d, %%=%d (workers=%d)" % (i, i % workers, workers))
#print sys.getsizeof(proc) # sizeof(proc array) [not so big]
if i % workers is 0:
# wait for the ones launched so far to finish
for p_i in depths[:i]:
pout[p_i] = proc[p_i].communicate()[0]
if proc[p_i].wait() is not 0:
grass.fatal(_("Trouble importing data. Aborting."))
# wait for jSobs to finish, collect any stray output
for i in depths:
pout[i] = proc[i].communicate()[0]
if proc[i].wait() is not 0:
grass.fatal(_("Trouble importing data. Aborting."))
del proc
grass.verbose(_("Assembling 3D cube ..."))
#input order: lower most strata first
slices = grass.read_command('g.list', type='raster', sep=',',
pattern='tmp.r3xyz.%d.*' % os.getpid()).rstrip(os.linesep)
grass.debug(slices)
try:
grass.run_command('r.to.rast3', input=slices, output=output)
except CalledModuleError:
grass.message(_("Done. 3D raster map <%s> created.") % output)
def tearDownClass(cls):
"""Remove copied vector"""
run_command("g.remove", type="vector", name="myroads", flags="f")
def remove_map(opts, flgs):
run_command("g.remove",
type="raster",
flags="f",
name="cable_crane_extraction")
run_command("g.remove",
type="raster",
flags="f",
name="forwarder_extraction")
run_command("g.remove", type="raster", flags="f", name="other_extraction")
run_command("g.remove", type="raster", flags="f", name="technical_surface")
run_command("g.remove", type="raster", flags="f", name="frict_surf_extr")
run_command("g.remove", type="raster", flags="f", name="extr_dist")
run_command("g.remove", type="raster", flags="f", name="yield_pix")
run_command("g.remove", type="raster", flags="f", name="yield_pix1")
run_command("g.remove", type="raster", flags="f", name="yield_pix2")
run_command("g.remove", type="raster", flags="f", name="pix_cross")
run_command("g.remove", type="raster", flags="f", name="slope_deg")
run_command("g.remove", type="raster", flags="f", name="slope")
def landform(scanned_elev, new, size=25, zscale=1, env=None):
gcore.run_command('r.param.scale', overwrite=True, input=scanned_elev, output=new, size=size, param='feature', zscale=zscale, env=env)
def setUpClass(cls):
gcore.use_temp_region()
gcore.run_command("g.region", raster="elevation")
def erosion(scanned_elev, rain_value, depth, detachment, transport, shearstress, niter, flux, erdep, slope=None, aspect=None, env=None):
pid = str(os.getpid())
options = {}
if slope:
options['slope'] = slope
if aspect:
options['aspect'] = aspect
dc, tc, tau = 'dc' + pid, 'tc' + pid, 'tau' + pid
gcore.run_command('r.slope.aspect', elevation=scanned_elev, dx='dx_' + pid, dy='dy' + pid, overwrite=True, env=env, **options)
gcore.run_command('r.sim.water', elevation=scanned_elev, dx='dx_' + pid, dy='dy' + pid, rain_value=rain_value, depth=depth, nwalk=10000, niter=niter, overwrite=True, env=env)
gcore.run_command('r.mapcalc', expression="{dc} = {detachment}".format(dc=dc, detachment=detachment), overwrite=True, env=env)
gcore.run_command('r.mapcalc', expression="{tc} = {transport}".format(tc=tc, transport=transport), overwrite=True, env=env)
gcore.run_command('r.mapcalc', expression="{tau} = {shearstress}".format(tau=tau, shearstress=shearstress), overwrite=True, env=env)
gcore.run_command('r.sim.sediment', elevation=scanned_elev, dx='dx_' + pid, dy='dy' + pid, wdepth=depth, det=dc, tran=tc, tau=tau, flux=flux, erdep=erdep, niter=niter, nwalk=10000, overwrite=True, env=env)
gcore.run_command('g.remove', rast=[dc, tc, tau, 'dx_' + pid, 'dy' + pid], env=env)
def main():
# default option
gisrc = read_gisrc(os.environ['GISRC'])
user = os.environ['USER']
# start optparse
usage = "usage: %prog [options]"
parser = optparse.OptionParser(usage=usage)
parser.add_option("-U",
"--user",
dest="user",
default=user,
help="PostgreSQL user [default=%default]")
parser.add_option("-P",
"--password",
dest="passwd",
default=None,
help="PostgreSQL password for user [default=%default]")
parser.add_option("-D",
"--database",
dest="db",
default='pygrassdb_doctest',
help="PostgreSQL database name [default=%default]")
(opts, args) = parser.parse_args()
#
# Create DB
#
print("\n\nCreate a new DB: %s...\n" % opts.db)
createdb = [
'createdb', '--encoding=UTF-8',
'--owner=%s' % opts.user, '--host=localhost',
'--username=%s' % opts.user, opts.db
]
if opts.passwd:
print opts.passwd
createdb.append("--password=%s" % opts.passwd)
else:
createdb.append("--no-password")
subprocess.Popen(createdb)
#
# set postgreSQL
#
print("\n\nSet Postgres connection...\n")
grasscore.run_command('db.connect',
driver='pg',
database='host=localhost,dbname=%s' % opts.db)
grasscore.run_command('db.login', user=opts.user)
print("\n\nCopy the map from PERMANENT to user1...\n")
grasscore.run_command('g.copy',
vect="boundary_municp@PERMANENT,boundary_municp_pg",
overwrite=True)
print("\n\nBuild topology...\n")
grasscore.run_command('v.build', map='boundary_municp_pg', overwrite=True)
#
# set sqlite
#
db = [
gisrc['GISDBASE'], gisrc['LOCATION_NAME'], gisrc['MAPSET'], 'sqlite.db'
]
print("\n\nSet Sqlite connection...\n")
grasscore.run_command('db.connect',
driver='sqlite',
database=os.path.join(db))
print("\n\nCopy the map from PERMANENT to user1...\n")
grasscore.run_command(
'g.copy',
vect="boundary_municp@PERMANENT,boundary_municp_sqlite",
overwrite=True)
print("\n\nBuild topology...\n")
grasscore.run_command('v.build',
map='boundary_municp_sqlite',
overwrite=True)
def slope_aspect(scanned_elev, slope, aspect, env, zfactor=1.):
gcore.run_command('r.slope.aspect', elevation=scanned_elev, zfactor=zfactor, aspect=aspect, slope=slope, overwrite=True, env=env)
gcore.run_command('r.colors', map=aspect, color='aspectcolr', env=env)
def main():
infile = options['input']
# create temporary directory
global tmp_dir
tmp_dir = grass.tempdir()
grass.debug('tmp_dir = %s' % tmp_dir)
# check if the input file exists
if not os.path.exists(infile):
grass.fatal(_("File <%s> not found") % infile)
# copy the files to tmp dir
input_base = os.path.basename(infile)
shutil.copyfile(infile, os.path.join(tmp_dir, input_base))
os.chdir(tmp_dir)
tar = tarfile.TarFile.open(name=input_base, mode='r')
try:
data_name = tar.getnames()[0]
except:
grass.fatal(_("Pack file unreadable"))
if flags['p']:
# print proj info and exit
try:
for fname in ['PROJ_INFO', 'PROJ_UNITS']:
f = tar.extractfile(fname)
sys.stdout.write(f.read().decode())
except KeyError:
grass.fatal(
_("Pack file unreadable: file '{}' missing".format(fname)))
tar.close()
return 0
# set the output name
if options['output']:
map_name = options['output']
else:
map_name = data_name
# grass env
gisenv = grass.gisenv()
mset_dir = os.path.join(gisenv['GISDBASE'], gisenv['LOCATION_NAME'],
gisenv['MAPSET'])
new_dir = os.path.join(mset_dir, 'vector', map_name)
gfile = grass.find_file(name=map_name, element='vector', mapset='.')
overwrite = os.getenv('GRASS_OVERWRITE')
if gfile['file'] and overwrite != '1':
grass.fatal(_("Vector map <%s> already exists") % map_name)
elif overwrite == '1' and gfile['file']:
grass.warning(
_("Vector map <%s> already exists and will be overwritten") %
map_name)
grass.run_command('g.remove',
flags='f',
quiet=True,
type='vector',
name=map_name)
shutil.rmtree(new_dir, True)
# extract data
tar.extractall()
tar.close()
if os.path.exists(os.path.join(data_name, 'coor')):
pass
elif os.path.exists(os.path.join(data_name, 'cell')):
grass.fatal(
_("This GRASS GIS pack file contains raster data. Use "
"r.unpack to unpack <%s>" % map_name))
else:
grass.fatal(_("Pack file unreadable"))
# check projection compatibility in a rather crappy way
loc_proj = os.path.join(mset_dir, '..', 'PERMANENT', 'PROJ_INFO')
loc_proj_units = os.path.join(mset_dir, '..', 'PERMANENT', 'PROJ_UNITS')
skip_projection_check = False
if not os.path.exists(os.path.join(tmp_dir, 'PROJ_INFO')):
if os.path.exists(loc_proj):
grass.fatal(
_("PROJ_INFO file is missing, unpack vector map in XY (unprojected) location."
))
skip_projection_check = True # XY location
if not skip_projection_check:
diff_result_1 = diff_result_2 = None
if not grass.compare_key_value_text_files(filename_a=os.path.join(
tmp_dir, 'PROJ_INFO'),
filename_b=loc_proj,
proj=True):
diff_result_1 = diff_files(os.path.join(tmp_dir, 'PROJ_INFO'),
loc_proj)
if not grass.compare_key_value_text_files(filename_a=os.path.join(
tmp_dir, 'PROJ_UNITS'),
filename_b=loc_proj_units,
units=True):
diff_result_2 = diff_files(os.path.join(tmp_dir, 'PROJ_UNITS'),
loc_proj_units)
if diff_result_1 or diff_result_2:
if flags['o']:
grass.warning(
_("Projection information does not match. Proceeding..."))
else:
if diff_result_1:
grass.warning(
_("Difference between PROJ_INFO file of packed map "
"and of current location:\n{diff}").format(
diff=''.join(diff_result_1)))
if diff_result_2:
grass.warning(
_("Difference between PROJ_UNITS file of packed map "
"and of current location:\n{diff}").format(
diff=''.join(diff_result_2)))
grass.fatal(
_("Projection of dataset does not appear to match current location."
" In case of no significant differences in the projection definitions,"
" use the -o flag to ignore them and use"
" current location definition."))
# new db
fromdb = os.path.join(tmp_dir, 'db.sqlite')
# copy file
shutil.copytree(data_name, new_dir)
# exist fromdb
if os.path.exists(fromdb):
# the db connection in the output mapset
dbconn = grassdb.db_connection(force=True)
todb = dbconn['database']
# return all tables
list_fromtable = grass.read_command('db.tables',
driver='sqlite',
database=fromdb).splitlines()
# return the list of old connection for extract layer number and key
dbln = open(os.path.join(new_dir, 'dbln'), 'r')
dbnlist = dbln.readlines()
dbln.close()
# check if dbf or sqlite directory exists
if dbconn['driver'] == 'dbf' and not os.path.exists(
os.path.join(mset_dir, 'dbf')):
os.mkdir(os.path.join(mset_dir, 'dbf'))
elif dbconn['driver'] == 'sqlite' and not os.path.exists(
os.path.join(mset_dir, 'sqlite')):
os.mkdir(os.path.join(mset_dir, 'sqlite'))
# for each old connection
for t in dbnlist:
# it split the line of each connection, to found layer number and key
if len(t.split('|')) != 1:
values = t.split('|')
else:
values = t.split(' ')
from_table = values[1]
layer = values[0].split('/')[0]
# we need to take care about the table name in case of several layer
if options["output"]:
if len(dbnlist) > 1:
to_table = "%s_%s" % (map_name, layer)
else:
to_table = map_name
else:
to_table = from_table
grass.verbose(
_("Coping table <%s> as table <%s>") % (from_table, to_table))
# copy the table in the default database
try:
grass.run_command('db.copy',
to_driver=dbconn['driver'],
to_database=todb,
to_table=to_table,
from_driver='sqlite',
from_database=fromdb,
from_table=from_table)
except CalledModuleError:
grass.fatal(
_("Unable to copy table <%s> as table <%s>") %
(from_table, to_table))
grass.verbose(
_("Connect table <%s> to vector map <%s> at layer <%s>") %
(to_table, map_name, layer))
# and connect the new tables with the right layer
try:
grass.run_command('v.db.connect',
flags='o',
quiet=True,
driver=dbconn['driver'],
database=todb,
map=map_name,
key=values[2],
layer=layer,
table=to_table)
except CalledModuleError:
grass.fatal(
_("Unable to connect table <%s> to vector map <%s>") %
(to_table, map_name))
grass.message(_("Vector map <%s> successfully unpacked") % map_name)
def aspect(scanned_elev, new, env):
gcore.run_command('r.slope.aspect', elevation=scanned_elev, aspect=new, overwrite=True, env=env)
c_ok = libvect.Vect_get_area_cats(self.c_mapinfo, a_id,
ctypes.byref(line_c))
if c_ok == 0: # Centroid found
ok = libvect.Vect_cat_get(ctypes.byref(line_c), field,
ctypes.byref(cat))
if ok > 0:
pcat = cat.value
l.append((a_id, pcat, ctypes.string_at(barray, size.value)))
libgis.G_free(barray)
return l
return None
if __name__ == "__main__":
import doctest
from grass.pygrass import utils
utils.create_test_vector_map(test_vector_name)
doctest.testmod()
"""Remove the generated vector map, if exist"""
from grass.pygrass.utils import get_mapset_vector
from grass.script.core import run_command
mset = get_mapset_vector(test_vector_name, mapset='')
if mset:
run_command("g.remove",
flags='f',
type='vector',
name=test_vector_name)
def flowacc(scanned_elev, new, env):
gcore.run_command('r.flow', elevation=scanned_elev, flowaccumulation=new, overwrite=True, env=env)
else:
newname = self.name
try:
cur.execute(sql.CREATE_TAB.format(tname=newname, coldef=coldef))
self.conn.commit()
except OperationalError: # OperationalError
if overwrite:
self.drop(force=True)
cur.execute(sql.CREATE_TAB.format(tname=newname, coldef=coldef))
self.conn.commit()
else:
print("The table: %s already exist." % self.name)
cur.close()
self.columns.update_odict()
if __name__ == "__main__":
import doctest
from grass.pygrass import utils
utils.create_test_vector_map(test_vector_name)
doctest.testmod()
"""Remove the generated vector map, if exist"""
from grass.pygrass.utils import get_mapset_vector
from grass.script.core import run_command
mset = get_mapset_vector(test_vector_name, mapset="")
if mset:
run_command("g.remove", flags="f", type="vector", name=test_vector_name)
def change_detection(before, after, change, height_threshold, cells_threshold, add, max_detected, env):
tmp_regions = []
env = get_environment(tmp_regions, rast=before, n='n-20', s='s+20', e='e-20', w='w+20')
diff_thr = 'diff_thr_' + str(os.getpid())
diff_thr_clump = 'diff_thr_clump_' + str(os.getpid())
change_vector = 'change_vector_' + str(os.getpid())
if add:
gcore.run_command('r.mapcalc', expression="{diff_thr} = if(({after} - {before}) > {thr1} &&"
" ({after} - {before}) < {thr2}, 1, null())".format(diff_thr=diff_thr, after=after,
before=before, thr1=height_threshold[0],
thr2=height_threshold[1]), env=env)
else:
gcore.run_command('r.mapcalc', expression="{diff_thr} = if(({before} - {after}) > {thr}, 1, null())".format(diff_thr=diff_thr,
after=after, before=before, thr=height_threshold), env=env)
gcore.run_command('r.clump', input=diff_thr, output=diff_thr_clump, env=env)
stats = gcore.read_command('r.stats', flags='cn', input=diff_thr_clump, sort='desc', env=env).strip().split(os.linesep)
if len(stats) > 0 and stats[0]:
print stats
cats = []
found = 0
for stat in stats:
if found >= max_detected:
break
if float(stat.split()[1]) < cells_threshold[1] and float(stat.split()[1]) > cells_threshold[0]: # larger than specified number of cells
found += 1
cat, value = stat.split()
cats.append(cat)
if cats:
expression = '{change} = if(('.format(change=change)
for i, cat in enumerate(cats):
if i != 0:
expression += ' || '
expression += '{diff_thr_clump} == {val}'.format(diff_thr_clump=diff_thr_clump, val=cat)
expression += '), 1, null())'
gcore.run_command('r.mapcalc', overwrite=True, env=env, expression=expression)
remove_vector(change_vector)
gcore.run_command('r.to.vect', flags='st', input=change, output=change_vector, type='area', env=env)
remove_vector(change)
gcore.run_command('v.to.points', flags='t', input=change_vector, type='centroid', output=change, env=env)
remove_vector(change_vector)
else:
gcore.warning("No change found!")
else:
gcore.warning("No change found!")
gcore.run_command('g.remove', rast=[diff_thr, diff_thr_clump])
remove_temp_regions(tmp_regions)
def main():
out = options['output']
wfs_url = options['url']
request_base = 'REQUEST=GetFeature&SERVICE=WFS&VERSION=1.0.0'
wfs_url += request_base
if options['name']:
wfs_url += '&TYPENAME=' + options['name']
if options['srs']:
wfs_url += '&SRS=' + options['srs']
if options['maximum_features']:
wfs_url += '&MAXFEATURES=' + options['maximum_features']
if int(options['maximum_features']) < 1:
# GTC Invalid WFS maximum features parameter
grass.fatal(_("Invalid maximum number of features"))
if options['start_index']:
wfs_url += '&STARTINDEX=' + options['start_index']
if int(options['start_index']) < 1:
# GTC Invalid WFS start index parameter
grass.fatal(_('Features begin with index "1"'))
if flags['r']:
bbox = grass.read_command("g.region", flags='w').split('=')[1]
wfs_url += '&BBOX=' + bbox
if flags['l']:
wfs_url = options['url'] + 'REQUEST=GetCapabilities&SERVICE=WFS&VERSION=1.0.0'
tmp = grass.tempfile()
tmpxml = tmp + '.xml'
grass.debug(wfs_url)
# Set user and password if given
if options['username'] and options['password']:
grass.message(_("Setting username and password..."))
if os.path.isfile(options['username']):
with open(options['username']) as f:
filecontent = f.read()
user = filecontent.strip()
elif options['username'] in os.environ:
user = os.environ[options['username']]
else:
user = options['username']
if os.path.isfile(options['password']):
with open(options['password']) as f:
filecontent = f.read()
pw = filecontent.strip()
elif options['password'] in os.environ:
pw = os.environ[options['password']]
else:
pw = options['password']
passmgr = HTTPPasswordMgrWithDefaultRealm()
passmgr.add_password(None, wfs_url,user, pw)
authhandler = HTTPBasicAuthHandler(passmgr)
opener = build_opener(authhandler)
install_opener(opener)
# GTC Downloading WFS features
grass.message(_("Retrieving data..."))
try:
inf = urlopen(wfs_url)
except HTTPError as e:
# GTC WFS request HTTP failure
grass.fatal(_("The server couldn't fulfill the request.\nError code: %s") % e.code)
except URLError as e:
# GTC WFS request network failure
grass.fatal(_("Failed to reach the server.\nReason: %s") % e.reason)
outf = open(tmpxml, 'wb')
while True:
s = inf.read()
if not s:
break
outf.write(s)
inf.close()
outf.close()
if flags['l']:
import shutil
if os.path.exists('wms_capabilities.xml'):
grass.fatal(_('A file called "wms_capabilities.xml" already exists here'))
# os.move() might fail if the temp file is on another volume, so we copy instead
shutil.copy(tmpxml, 'wms_capabilities.xml')
try_remove(tmpxml)
sys.exit(0)
grass.message(_("Importing data..."))
try:
grass.run_command('v.in.ogr', flags='o', input=tmpxml, output=out)
grass.message(_("Vector map <%s> imported from WFS.") % out)
except:
grass.message(_("WFS import failed"))
finally:
try_remove(tmpxml)
def main():
infile = options["input"]
compression_off = flags["c"]
global basedir
basedir = grass.tempdir()
# check if vector map exists
gfile = grass.find_file(infile, element="vector")
if not gfile["name"]:
grass.fatal(_("Vector map <%s> not found") % infile)
# check if input vector map is in the native format
if vector.vector_info(gfile["fullname"])["format"] != "native":
grass.fatal(
_("Unable to pack vector map <%s>. Only native format supported.")
% gfile["fullname"])
# split the name if there is the mapset name
if infile.find("@"):
infile = infile.split("@")[0]
# output name
if options["output"]:
outfile = options["output"]
else:
outfile = infile + ".pack"
# check if exists the output file
if os.path.exists(outfile):
if os.getenv("GRASS_OVERWRITE"):
grass.warning(
_("Pack file <%s> already exists and will be overwritten") %
outfile)
try_remove(outfile)
else:
grass.fatal(_("option <%s>: <%s> exists.") % ("output", outfile))
# prepare for packing
grass.verbose(_("Packing <%s>...") % (gfile["fullname"]))
# write tar file, optional compression
if compression_off:
tar = tarfile.open(name=outfile, mode="w:")
else:
tar = tarfile.open(name=outfile, mode="w:gz")
tar.add(gfile["file"], infile)
# check if exist a db connection for the vector
db_vect = vector.vector_db(gfile["fullname"])
if not db_vect:
grass.verbose(
_("There is not database connected with vector map <%s>") %
gfile["fullname"])
else:
# for each layer connection save a table in sqlite database
sqlitedb = os.path.join(basedir, "db.sqlite")
for i, dbconn in db_vect.items():
grass.run_command(
"db.copy",
from_driver=dbconn["driver"],
from_database=dbconn["database"],
from_table=dbconn["table"],
to_driver="sqlite",
to_database=sqlitedb,
to_table=dbconn["table"],
)
tar.add(sqlitedb, "db.sqlite")
# add to the tar file the PROJ files to check when unpack file
gisenv = grass.gisenv()
for support in ["INFO", "UNITS", "EPSG"]:
path = os.path.join(gisenv["GISDBASE"], gisenv["LOCATION_NAME"],
"PERMANENT", "PROJ_" + support)
if os.path.exists(path):
tar.add(path, "PROJ_" + support)
tar.close()
grass.message(
_("Pack file <%s> created") % os.path.join(os.getcwd(), outfile))
def usped(scanned_elev, k_factor, c_factor, flowacc, slope, aspect, new, env):
"""!Computes net erosion and deposition (USPED model)"""
sedflow = 'sedflow_' + str(os.getpid())
qsx = 'qsx_' + str(os.getpid())
qsxdx = 'qsxdx_' + str(os.getpid())
qsy = 'qsy_' + str(os.getpid())
qsydy = 'qsydy_' + str(os.getpid())
slope_sm = 'slope_sm' + str(os.getpid())
gcore.run_command('r.neighbors', overwrite=True, input=slope, output=slope_sm, size=5, env=env)
gcore.run_command('r.mapcalc', expression="{sedflow} = 270. * {k_factor} * {c_factor} * {flowacc} * sin({slope})".format(c_factor=c_factor, k_factor=k_factor, slope=slope_sm, flowacc=flowacc, sedflow=sedflow), overwrite=True, env=env)
gcore.run_command('r.mapcalc', expression="{qsx} = {sedflow} * cos({aspect})".format(sedflow=sedflow, aspect=aspect, qsx=qsx), overwrite=True, env=env)
gcore.run_command('r.mapcalc', expression="{qsy} = {sedflow} * sin({aspect})".format(sedflow=sedflow, aspect=aspect, qsy=qsy), overwrite=True, env=env)
gcore.run_command('r.slope.aspect', elevation=qsx, dx=qsxdx, overwrite=True, env=env)
gcore.run_command('r.slope.aspect', elevation=qsy, dy=qsydy, overwrite=True, env=env)
gcore.run_command('r.mapcalc', expression="{erdep} = {qsxdx} + {qsydy}".format(erdep=new, qsxdx=qsxdx, qsydy=qsydy), overwrite=True, env=env)
gcore.write_command('r.colors', map=new, rules='-', stdin='-15000 100 0 100\n-100 magenta\n-10 red\n-1 orange\n-0.1 yellow\n0 200 255 200\n0.1 cyan\n1 aqua\n10 blue\n100 0 0 100\n18000 black', env=env)
gcore.run_command('g.remove', rast=[sedflow, qsx, qsxdx, qsy, qsydy, slope_sm])
def main():
global tmp
infile = options['input']
output = options['output']
matlab = flags['f']
threeD = flags['z']
prog = 'v.in.mapgen'
opts = ""
if not os.path.isfile(infile):
grass.fatal(_("Input file <%s> not found") % infile)
if output:
name = output
else:
name = ''
if threeD:
matlab = True
if threeD:
do3D = 'z'
else:
do3D = ''
tmp = grass.tempfile()
#### create ascii vector file
inf = file(infile)
outf = file(tmp, 'w')
grass.message(_("Importing data..."))
cat = 1
if matlab:
## HB: OLD v.in.mapgen.sh Matlab import command follows.
## I have no idea what it's all about, so "new" matlab format will be
## a series of x y with "nan nan" breaking lines. (as NOAA provides)
## Old command:
# tac $infile | $AWK 'BEGIN { FS="," ; R=0 }
# $1~/\d*/ { printf("L %d\n", R) }
# $1~/ .*/ { printf(" %lf %lf\n", $2, $1) ; ++R }
# $1~/END/ { }' | tac > "$TMP"
## matlab format.
points = []
for line in inf:
f = line.split()
if f[0].lower() == 'nan':
if points != []:
outf.write("L %d 1\n" % len(points))
for point in points:
outf.write(" %.15g %.15g %.15g\n" %
tuple(map(float, point)))
outf.write(" 1 %d\n" % cat)
cat += 1
points = []
else:
if len(f) == 2:
f.append('0')
points.append(f)
if points != []:
outf.write("L %d 1\n" % len(points))
for point in points:
try:
outf.write(" %.15g %.15g %.15g\n" %
tuple(map(float, point)))
except ValueError:
grass.fatal(
_("An error occurred on line '%s', exiting.") %
line.strip())
outf.write(" 1 %d\n" % cat)
cat += 1
else:
## mapgen format.
points = []
for line in inf:
if line[0] == '#':
if points != []:
outf.write("L %d 1\n" % len(points))
for point in points:
outf.write(" %.15g %.15g\n" % tuple(map(float, point)))
outf.write(" 1 %d\n" % cat)
cat += 1
points = []
else:
points.append(line.rstrip('\r\n').split('\t'))
if points != []:
outf.write("L %d 1\n" % len(points))
for point in points:
outf.write(" %.15g %.15g\n" % tuple(map(float, point)))
outf.write(" 1 %d\n" % cat)
cat += 1
outf.close()
inf.close()
#### create digit header
digfile = tmp + '.dig'
outf = file(digfile, 'w')
t = string.Template(\
"""ORGANIZATION: GRASSroots organization
DIGIT DATE: $date
DIGIT NAME: $user@$host
MAP NAME: $name
MAP DATE: $year
MAP SCALE: 1
OTHER INFO: Imported with $prog
ZONE: 0
MAP THRESH: 0
VERTI:
""")
date = time.strftime("%m/%d/%y")
year = time.strftime("%Y")
user = os.getenv('USERNAME') or os.getenv('LOGNAME')
host = os.getenv('COMPUTERNAME') or os.uname()[1]
s = t.substitute(prog=prog,
name=name,
date=date,
year=year,
user=user,
host=host)
outf.write(s)
#### process points list to ascii vector file (merge in vertices)
inf = file(tmp)
shutil.copyfileobj(inf, outf)
inf.close()
outf.close()
if not name:
#### if no name for vector file given, cat to stdout
inf = file(digfile)
shutil.copyfileobj(inf, sys.stdout)
inf.close()
else:
#### import to binary vector file
grass.message(_("Importing with v.in.ascii..."))
if grass.run_command('v.in.ascii',
flags=do3D,
input=digfile,
output=name,
format='standard') != 0:
grass.fatal(
_('An error occurred on creating "%s", please check') % name)
def setUpClass(cls):
"""Copy vector."""
run_command("g.copy", vector="roadsmajor,myroads")
