def __init__(self, options):
self._tmpxyz = grass.tempfile()
self._xyzout = grass.tempfile()
self._tmp = grass.tempfile()
self._tmpcat = grass.tempfile()
self.options = options
self.region()
pass
def _saveToFile(self, fileName, fileType):
"""Creates composite image by rendering both images and
pasting them into the new one.
.. todo::
specify size of the new image (problem is inaccurate scaling)
.. todo::
make dividing line width and color optional
"""
w1 = self.splitter.GetWindow1()
w2 = self.splitter.GetWindow2()
lineWidth = 1
# render to temporary files
filename1 = grass.tempfile(False) + '1'
filename2 = grass.tempfile(False) + '2'
width, height = self.splitter.GetClientSize()
if self._mode == 'swipe':
x, y = w2.GetImageCoords()
w1.SaveToFile(filename1, fileType, width, height)
w2.SaveToFile(filename2, fileType, width, height)
else:
fw, fh = w1.GetClientSize()
w1.SaveToFile(filename1, fileType, fw, fh)
sw, sh = w2.GetClientSize()
w2.SaveToFile(filename2, fileType, sw, sh)
# create empty white image - needed for line
im = wx.EmptyImage(width, height)
im.Replace(0, 0, 0, 255, 255, 255)
# paste images
if self._mode == 'swipe':
if self.splitter.GetSplitMode() == wx.SPLIT_HORIZONTAL:
im1 = wx.Image(filename1).GetSubImage((0, 0, width, -y))
im.Paste(im1, 0, 0)
im.Paste(wx.Image(filename2), -x, -y + lineWidth)
else:
im1 = wx.Image(filename1).GetSubImage((0, 0, -x, height))
im.Paste(im1, 0, 0)
im.Paste(wx.Image(filename2), -x + lineWidth, -y)
else:
if self.splitter.GetSplitMode() == wx.SPLIT_HORIZONTAL:
im1 = wx.Image(filename1)
im.Paste(im1, 0, 0)
im.Paste(wx.Image(filename2), 0, fh + lineWidth)
else:
im1 = wx.Image(filename1)
im.Paste(im1, 0, 0)
im.Paste(wx.Image(filename2), fw + lineWidth, 0)
im.SaveFile(fileName, fileType)
# remove temporary files
grass.try_remove(filename1)
grass.try_remove(filename2)
def create_banks(cutline_pts, bank_dist, out_vect):
"""
Use the two lists of cutline point locations, and distances along those cutlines
To create points for the left and right bank locations
"""
cl_cnt = len(cutline_pts)
bk_cnt = len(bank_dist)
if (cl_cnt <> bk_cnt):
grass.fatal("Number of cutlines: %s, not equal to number of bank points: %s" % (cl_cnt, bk_cnt))
sys.exit(0)
tmp_coords = grass.tempfile()
tmp_banks = grass.tempfile()
proc=os.getpid()
# tmp_line holds a temporary line vector for each single cutline
# The locations in bank_dist will be used to create new points as bank points
# and added to the bank points vector, tmp_pts
tmp_line = "cutline_tmp_"+str(proc)
tmp_pts = "bankpt_tmp_"+str(proc)
grass.run_command('v.edit', map=out_vect, tool='create', type_='point',overwrite=True)
for i in range(len(cutline_pts)):
with open(tmp_coords,'w') as tmp:
tmp.write("VERTI:\n")
tmp.write("L 3 1\n")
tmp.write(" "+cutline_pts[i][0][0]+" "+cutline_pts[i][0][1]+"\n" )
tmp.write(" "+cutline_pts[i][1][0]+" "+cutline_pts[i][1][1]+"\n" )
tmp.write(" "+cutline_pts[i][2][0]+" "+cutline_pts[i][2][1]+"\n" )
tmp.write(" 1 1\n")
tmp.close()
# Create one cutline (from 3 points)
grass.run_command('v.in.ascii',input_=tmp_coords, output=tmp_line, overwrite=True, format_='standard', quiet=True)
# Now find the point locations at the bank dist distances along that line
# Use the same list index, i, to get the points for the current cutline
# and multiply fraction by 100 to create % distance along cutline
with open(tmp_banks, 'w') as tmp:
rule_line1 = "P 1 1\n"
tmp.write("P 1 1 %s" % str(float(bank_dist[i][0])*100) + "%\n")
tmp.write("P 2 1 %s" % str(float(bank_dist[i][1])*100) + "%\n")
tmp.close()
# Create a new point vector, and append to existing bank points
grass.run_command('v.segment', input_=tmp_line, output=tmp_pts, rules=tmp_banks, overwrite=True, quiet=True)
grass.run_command('v.patch', input_=tmp_pts, output=out_vect, overwrite=True, flags='a', quiet=True )
# Cleanup
os.unlink(tmp_coords)
os.unlink(tmp_banks)
grass.run_command('g.remove', type_='vect', name=tmp_line, flags='f')
grass.run_command('g.remove', type_='vect', name=tmp_pts, flags='f')
def main():
try:
from owslib.ogcapi.coverages import Coverages
except:
grass.fatal(
_("OSWLib was not found. Install OSWLib (http://geopython.github.com/OWSLib/)."
))
feats = Coverages(options["url"])
collections = feats.coverages()
if flags["l"]:
for coll in collections:
print("{}".format(coll))
return
if not options["layer"]:
grass.fatal(
_("Required parameter <layer> not set: (Name for input vector map layer)"
))
elif options["layer"] not in collections:
grass.fatal(_("Layer {} is not a Coverage layer"))
if not options["output"]:
grass.fatal(
_("Required parameter <output> not set: (Name for output vector map)"
))
try:
layer = feats.coverage(options["layer"])
except Exception as e:
grass.fatal(
_("Problem retrieving data from the server. The error was: {}".
format(e)))
tmpfile = grass.tempfile()
with open(tmpfile, "wb") as f:
f.write(layer.getbuffer())
grass.run_command("r.import", input=tmpfile, output=options["output"])
def main():
global tmp
tmp = grass.tempfile()
vector = options['map']
layer = options['layer']
column = options['column']
where = options['where']
perc = options['percentile']
extend = flags['e']
shellstyle = flags['g']
fi = grass.vector_db(vector, stderr=nuldev)[int(layer)]
table = fi['table']
database = fi['database']
driver = fi['driver']
passflags = None
if flags['e']:
passflags = 'e'
if flags['g']:
if not passflags:
passflags = 'g'
else:
passflags = passflags + 'g'
grass.run_command('db.univar',
table=table,
column=column,
database=database,
driver=driver,
perc=perc,
where=where,
flags=passflags)
def main():
# Get the options
input = options["input"]
output = options["output"]
method = options["method"]
order = options["order"]
where = options["where"]
add_time = flags["t"]
nulls = flags["n"]
# Make sure the temporal database exists
tgis.init()
sp = tgis.open_old_stds(input, "strds")
rows = sp.get_registered_maps("id", where, order, None)
if rows:
# Create the r.series input file
filename = grass.tempfile(True)
file = open(filename, 'w')
for row in rows:
string = "%s\n" % (row["id"])
file.write(string)
file.close()
flag = ""
if len(rows) > 1000:
grass.warning(_("Processing over 1000 maps: activating -z flag of r.series which slows down processing"))
flag += "z"
if nulls:
flag += "n"
try:
grass.run_command("r.series", flags=flag, file=filename,
output=output, overwrite=grass.overwrite(),
method=method)
except CalledModuleError:
grass.fatal(_("%s failed. Check above error messages.") % 'r.series')
if not add_time:
# Create the time range for the output map
if output.find("@") >= 0:
id = output
else:
mapset = grass.gisenv()["MAPSET"]
id = output + "@" + mapset
map = sp.get_new_map_instance(id)
map.load()
map.set_temporal_extent(sp.get_temporal_extent())
# Register the map in the temporal database
if map.is_in_db():
map.update_all()
else:
map.insert()
def OnRun(self, event):
"""Run Python script"""
if self.running:
# ignore when already running
return
if not self.filename:
self.filename = gscript.tempfile()
self.tempfile = True
try:
fd = open(self.filename, "w")
fd.write(self.body.GetText())
except IOError as e:
GError(_("Unable to launch Python script. %s") % e,
parent=self.guiparent)
return
finally:
fd.close()
mode = stat.S_IMODE(os.lstat(self.filename)[stat.ST_MODE])
os.chmod(self.filename, mode | stat.S_IXUSR)
else:
fd = open(self.filename, "w")
try:
fd.write(self.body.GetText())
finally:
fd.close()
# set executable file
# (not sure if needed every time but useful for opened files)
os.chmod(self.filename, stat.S_IRWXU | stat.S_IWUSR)
# TODO: add overwrite to toolbar, needs env in GConsole
# run in console as other modules, avoid Python shell which
# carries variables over to the next execution
self.giface.RunCmd([fd.name], skipInterface=True, onDone=self.OnDone)
self.running = True
def string_to_rules(string):
"""Converts a string to a file for input as a GRASS Rules File"""
tmp = gs.tempfile()
f = open("%s" % (tmp), "wt")
f.write(string)
f.close()
return tmp
def AddScattPlot(self, cat_id, scatt_id):
if cat_id not in self.cats:
return -1
if scatt_id in self.cats[cat_id]:
return 0
b_i = self.GetBandsInfo(scatt_id)
shape = (
b_i['b2']['max'] -
b_i['b2']['min'] +
1,
b_i['b1']['max'] -
b_i['b1']['min'] +
1)
np_vals = np.memmap(
grass.tempfile(),
dtype=self.dtype,
mode='w+',
shape=shape)
self.cats[cat_id][scatt_id] = {'np_vals': np_vals}
return 1
def main():
global tmp
tmp = grass.tempfile()
vector = options['map']
layer = options['layer']
column = options['column']
where = options['where']
perc = options['percentile']
extend = flags['e']
shellstyle = flags['g']
fi = grass.vector_db(vector, stderr = nuldev)[int(layer)]
table = fi['table']
database = fi['database']
driver = fi['driver']
passflags = None
if flags['e']:
passflags = 'e'
if flags['g']:
if not passflags:
passflags = 'g'
else:
passflags = passflags + 'g'
grass.run_command('db.univar', table = table, column = column,
database = database, driver = driver,
perc = perc, where = where, flags = passflags)
def createTMPlocation(epsg=4326):
SRCGISRC = grass.tempfile()
TMPLOC = "temp_import_location_" + str(os.getpid())
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()
# create temp location from input without import
grass.verbose(_("Creating temporary location with EPSG:%d...") % epsg)
grass.run_command("g.proj", flags="c", epsg=epsg, location=TMPLOC, quiet=True)
# switch to temp location
os.environ["GISRC"] = str(SRCGISRC)
proj = grass.parse_command("g.proj", flags="g")
if "epsg" in proj:
currepsg = proj["epsg"]
else:
currepsg = proj["srid"].split("EPSG:")[1]
if currepsg != str(epsg):
grass.fatal("Creation of temporary location failed!")
return SRCGISRC, TMPLOC
def OnRun(self, event):
"""Run Python script"""
if not self.filename:
self.filename = gscript.tempfile() + ".py"
self.tempfile = True
file_is_written = self._writeFile(
file_path=self.filename,
content=self.body.GetText(),
additional_err_message=" Unable to launch Python script.",
)
if file_is_written:
mode = stat.S_IMODE(os.lstat(self.filename)[stat.ST_MODE])
os.chmod(self.filename, mode | stat.S_IXUSR)
else:
# always save automatically before running
file_is_written = self._writeFile(
file_path=self.filename,
content=self.body.GetText(),
additional_err_message=" Unable to launch Python script.",
)
if file_is_written:
# set executable file
# (not sure if needed every time but useful for opened files)
os.chmod(self.filename, stat.S_IRWXU | stat.S_IWUSR)
if file_is_written:
# run in console as other modules, avoid Python shell which
# carries variables over to the next execution
env = os.environ.copy()
if self.overwrite:
env["GRASS_OVERWRITE"] = "1"
cmd = [self.filename]
if self.parameters:
cmd.extend(self.parameters)
self.giface.RunCmd(cmd, env=env)
def createTMPlocation(epsg=4326):
SRCGISRC = grass.tempfile()
TMPLOC = 'temp_import_location_' + str(os.getpid())
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()
# create temp location from input without import
grass.verbose(_("Creating temporary location with EPSG:%d...") % epsg)
grass.run_command('g.proj',
flags='c',
epsg=epsg,
location=TMPLOC,
quiet=True)
# switch to temp location
os.environ['GISRC'] = str(SRCGISRC)
proj = grass.parse_command('g.proj', flags='g')
if 'epsg' in proj:
currepsg = proj['epsg']
else:
currepsg = proj['srid'].split('EPSG:')[1]
currepsg = ":".join(srid.split(":")[-1:])
if currepsg != str(epsg):
grass.fatal("Creation of temporary location failed!")
return SRCGISRC, TMPLOC
def create_pointmap(units, groups, groupsets, pointmapname, overwrite=True):
"""Transform info from json files into a GRASS GIS point map."""
tempfile = grass.tempfile()
groupsnotfound = []
groupsetsnotfound = []
with open(tempfile, 'w') as fout:
for unit in units.keys():
output = []
output.append(str(unit))
for v in units[unit]:
output.append(str(v))
if unit in groups:
groupid = groups[unit]['groupid']
groupname = groups[unit]['groupname']
else:
# if groupid not in groupsnotfound:
# groupsnotfound.append(groupid)
groupid = ''
groupname = ''
output.append(str(groupid))
output.append(str(groupname))
if groupid in groupsets:
groupsetid = groupsets[groupid]['groupsetid']
groupsetname = groupsets[groupid]['groupsetname']
else:
# if groupsetid not in groupsetsnotfound:
# groupsetsnotfound.append(groupsetid)
groupsetid = ''
groupsetname = ''
output.append(str(groupsetid))
output.append(str(groupsetname))
output_string = ','.join(output)
fout.write(output_string)
fout.write('\n')
if groupsnotfound:
warning_message = "Could not find the following groups:\n"
for group in groupsnotfound:
warning_message += "%s\n" % group
grass.warning(warning_message)
if groupsetsnotfound:
warning_message = "Could not find the following groupsets:\n"
for groupset in groupsetsnotfound:
warning_message += "%s\n" % groupset
grass.warning(warning_message)
columns = 'id varchar, x double precision, y double precision, name varchar, shortName varchar, groupid varchar, groupname varchar, groupsetid varchar, groupsetname varchar'
grass.run_command('v.in.ascii',
output=pointmapname,
input_=tempfile,
x=2,
y=3,
columns=columns,
separator='comma',
overwrite=overwrite,
quiet=True)
def main():
# lazy imports
import grass.temporal as tgis
# Get the options
_input = options["input"]
output = options["output"]
source = options["source"]
target = options["target"]
# Make sure the temporal database exists
tgis.init()
# We need a database interface
dbif = tgis.SQLDatabaseInterfaceConnection()
dbif.connect()
# specs of input strds
sp = tgis.open_old_stds(input, "strds", dbif)
ttype, stype, title, descr = sp.get_initial_values()
dbif.close()
# t.rast.list with columns name, start date, band reference
rlist = grass.read_command("t.rast.list",
input=_input,
columns="name,start_time,band_reference",
flags="u")
rlistfile = grass.tempfile(create=False)
fd = open(rlistfile, "w")
if source:
source = source.split(',')
target = target.split(',')
# modify band names
for rmap in rlist.splitlines():
name, start_time, band_reference = rmap.split('|')
if source:
if band_reference in source:
idx = source.index(band_reference)
band_reference = target[idx]
else:
band_reference = target[0]
fd.write("%s|%s|%s\n" % (name, start_time, band_reference))
fd.close()
# t.create, use specs of input strds
grass.run_command('t.create',
type='strds',
output=output,
temporaltype=ttype,
semantictype=stype,
title=title,
description=descr)
# t.register to create new strds
grass.run_command('t.register', input=output, file=rlistfile)
def tmp_map_name(name):
"""
Return a temporary map name, for example:
tmp_avg_lse = tmp + '.avg_lse'
"""
temporary_file = grass.tempfile()
tmp = "tmp." + grass.basename(temporary_file) # use its basename
return tmp + '.' + str(name)
def string_to_rules(string):
# Converts a string to a file for input as a GRASS Rules File
tmp = gs.tempfile()
f = open('%s' % (tmp), 'wt')
f.write(string)
f.close()
return tmp
def tmp_map_name(name):
"""
Return a temporary map name, for example:
tmp_avg_lse = tmp + '.avg_lse'
"""
temporary_file = grass.tempfile()
tmp = "tmp." + grass.basename(temporary_file) # use its basename
return tmp + '.' + str(name)
def _reprojectMap(self):
"""!Reproject data using gdalwarp if needed
"""
# reprojection of raster
if self.proj_srs != self.proj_location: # TODO: do it better
grass.message(_("Reprojecting raster..."))
self.temp_warpmap = grass.tempfile()
if int(os.getenv('GRASS_VERBOSE', '2')) <= 2:
nuldev = file(os.devnull, 'w+')
else:
nuldev = None
if self.params['method'] == "nearest":
gdal_method = "near"
elif self.params['method'] == "linear":
gdal_method = "bilinear"
else:
gdal_method = self.params['method']
#"+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0 +k=1.0 +units=m +nadgrids=@null +no_defs"
# RGB rasters - alpha layer is added for cropping edges of projected raster
try:
if self.temp_map_bands_num == 3:
ps = grass.Popen([
'gdalwarp', '-s_srs',
'%s' % self.proj_srs, '-t_srs',
'%s' % self.proj_location, '-r', gdal_method,
'-dstalpha', self.temp_map, self.temp_warpmap
],
stdout=nuldev)
# RGBA rasters
else:
ps = grass.Popen([
'gdalwarp', '-s_srs',
'%s' % self.proj_srs, '-t_srs',
'%s' % self.proj_location, '-r', gdal_method,
self.temp_map, self.temp_warpmap
],
stdout=nuldev)
ps.wait()
except OSError as e:
grass.fatal('%s \nThis can be caused by missing %s utility. ' %
(e, 'gdalwarp'))
if nuldev:
nuldev.close()
if ps.returncode != 0:
grass.fatal(_('%s failed') % 'gdalwarp')
grass.try_remove(self.temp_map)
# raster projection is same as projection of location
else:
self.temp_warpmap = self.temp_map
self.temp_files_to_cleanup.remove(self.temp_map)
return self.temp_warpmap
def main():
# Get the options
input = options["input"]
output = options["output"]
method = options["method"]
order = options["order"]
where = options["where"]
add_time = flags["t"]
nulls = flags["n"]
# Make sure the temporal database exists
tgis.init()
sp = tgis.open_old_stds(input, "strds")
rows = sp.get_registered_maps("id", where, order, None)
if rows:
# Create the r.series input file
filename = grass.tempfile(True)
file = open(filename, 'w')
for row in rows:
string = "%s\n" % (row["id"])
file.write(string)
file.close()
flag = "z"
if nulls:
flag += "n"
ret = grass.run_command("r.series",
flags=flag,
file=filename,
output=output,
overwrite=grass.overwrite(),
method=method)
if ret == 0 and not add_time:
# Create the time range for the output map
if output.find("@") >= 0:
id = output
else:
mapset = grass.gisenv()["MAPSET"]
id = output + "@" + mapset
map = sp.get_new_map_instance(id)
map.load()
map.set_temporal_extent(sp.get_temporal_extent())
# Register the map in the temporal database
if map.is_in_db():
map.update_all()
else:
map.insert()
def map_timestamps(directory, bands):
tmpfile = grass.tempfile()
mtl = process_mtl(directory)
with open(tmpfile, 'w') as f:
for band in bands:
basename = band[band.find('LT'):].split('_')[0]
starttime = datetime.datetime.strptime(mtl[basename]['date'], '%Y-%m-%d %H:%M:%S')
endtime = starttime + datetime.timedelta(seconds=1)
f.write('{}|{}|{}{}'.format(band, starttime, endtime, os.linesep))
return tmpfile
def write_segarcdefs(lineinfo, maxcat):
filename = gscript.tempfile()
with open(filename, 'w') as fout:
for arccat in lineinfo:
for cat in range(1, maxcat):
pointcat = arccat * 10000 + cat
fout.write("%d %d %d\n" % (arccat, pointcat, pointcat + 1))
return filename
def __init__(
self,
parent,
giface,
layer,
ws_cap_files,
cmd,
id=wx.ID_ANY,
style=wx.DEFAULT_DIALOG_STYLE | wx.RESIZE_BORDER,
**kwargs,
):
"""
:param giface: grass interface
:param layer: layer tree item
:param ws_cap_files: dict web service('WMS_1.1.1', 'WMS_1.3.0',
'WMTS', 'OnEarth') : cap file path cap files, which will be parsed
:param cmd: cmd to which dialog widgets will be initialized if
it is possible (cmp parameters exists in parsed web service cap_file)
"""
WSDialogBase.__init__(
self,
parent,
id=wx.ID_ANY,
style=wx.DEFAULT_DIALOG_STYLE | wx.RESIZE_BORDER,
**kwargs,
)
self.SetTitle(_("Web service layer properties"))
self.layer = layer
self.giface = giface
# after web service panels are connected, set dialog widgets
# according to cmd in this variable (if it is not None)
self.cmd_to_set = None
# store data needed for reverting
self.revert_ws_cap_files = {}
self.revert_cmd = cmd
ws_cap = self._getWSfromCmd(cmd)
for ws in six.iterkeys(self.ws_panels):
# cap file used in cmd will be deleted, thnaks to the dialogs
# destructor
if ws == ws_cap and "capfile" in cmd[1]:
self.revert_ws_cap_files[ws] = cmd[1]["capfile"]
del ws_cap_files[ws]
else:
self.revert_ws_cap_files[ws] = grass.tempfile()
self._setRevertCapFiles(ws_cap_files)
self.LoadCapFiles(ws_cap_files=self.revert_ws_cap_files, cmd=cmd)
self.btn_ok.SetDefault()
def mkstreams(self):
'''Create minimal stream network reaching all subbasins and with nice main streams'''
# get max accumulation and cell count for each subbasin
rsmaxaccum = gread('r.stats', input='maxaccum__', flags='lcn')
rsmaxaccum = np.array(rsmaxaccum.split(), dtype=float).reshape((-1, 3)).astype(int)
subbasinIDs = rsmaxaccum[:, 0]
maxaccum = rsmaxaccum[:, 1]
# cellcounts must not be larger than maxaccum (may happen in subbasins with more than 1 outlet)
cellcounts = np.min([rsmaxaccum[:, 2], maxaccum], axis=0)
# calculate optima accumulation for nice headwater mainstreams
accr = grass.parse_command('r.info', map=self.accumulation, flags='g')
minaccum = np.int32(round(float(self.minmainstreams)*1e6 /
(float(accr['nsres'])*float(accr['ewres']))))
minaccum = np.ones_like(maxaccum) * minaccum
optiaccum = np.min([maxaccum-np.int32(cellcounts*0.1), minaccum], axis=0)
# check incoming subbasins maxaccum and take the smallest accumulation to update optiaccum
subnext = readSubNxtID(self.outlets)
optiaccum = dict(zip(subbasinIDs,optiaccum))
maxaccum = dict(zip(subbasinIDs,maxaccum))
for sn in np.unique(subnext['nextID']):
if sn < 0: continue
for sb in subnext[subnext['nextID']==sn]['subbasinID']:
optiaccum[sn] = min(optiaccum[sn],maxaccum[sb]-1)
# make raster
tempf = grass.tempfile()
np.savetxt(tempf,optiaccum.items(),fmt='%i=%i')
grass.run_command('r.reclass',input='maxaccum__',output='optiaccum__',
rules=tempf,quiet=True)
# get accumulation and make lines
grass.mapcalc("{0}__unthin=if({1} > {2},{1},null())".format(self.mainstreams,
self.accumulation,'optiaccum__'),overwrite=True)
# make sure all pixels between outlets and inlets are included
#grun('v.to.rast',input=self.outletinletlines,output='routingnet__rast',
# use='val',type='line',quiet=True)
#grass.mapcalc("{0}=if(isnull({0})&~isnull({1}),{2},{0})".format(self.mainstreams,
# 'routingnet__rast',self.accumulation),overwrite=True)
grun('r.thin', input=self.mainstreams+'__unthin', output=self.mainstreams, overwrite=True, quiet=True) # may exclude outlet/inlet points
# use predefined streams for subbasins that have them
if 'streams' in self.options:
grun('v.to.rast',input=self.streams,output='stream__rast',
use='val',type='line',val=1,quiet=True)
grun('r.thin', input='stream__rast', output='stream__rast__thin',
overwrite=True, quiet=True)
grun('r.stats.zonal',base=self.subbasinrast,cover='stream__rast__thin',
method='sum',output='n__streams__subbasins',quiet=True,overwrite=True)
# get subbasins that have at least x cells of streams
grass.mapcalc('{0}=if(n__streams__subbasins>10,{1},{0})'.format(self.mainstreams,'stream__rast__thin'),
overwrite=True)
# make final vector
grun('r.to.vect', input=self.mainstreams, output=self.mainstreams,
type='line',quiet=True)
return
def main():
# Get the options
input = options["input"]
output = options["output"]
method = options["method"]
order = options["order"]
where = options["where"]
add_time = flags["t"]
nulls = flags["n"]
# Make sure the temporal database exists
tgis.init()
sp = tgis.open_old_stds(input, "strds")
rows = sp.get_registered_maps("id", where, order, None)
if rows:
# Create the r.series input file
filename = grass.tempfile(True)
file = open(filename, 'w')
for row in rows:
string = "%s\n" % (row["id"])
file.write(string)
file.close()
flag = "z"
if nulls:
flag += "n"
ret = grass.run_command("r.series", flags=flag, file=filename,
output=output, overwrite=grass.overwrite(),
method=method)
if ret == 0 and not add_time:
# Create the time range for the output map
if output.find("@") >= 0:
id = output
else:
mapset = grass.gisenv()["MAPSET"]
id = output + "@" + mapset
map = sp.get_new_map_instance(id)
map.load()
map.set_temporal_extent(sp.get_temporal_extent())
# Register the map in the temporal database
if map.is_in_db():
map.update_all()
else:
map.insert()
def main(rinput, background, output, method):
if '@' in rinput:
rinput = rinput.split('@')[0]
suffix = '_' + os.path.basename(gscript.tempfile(False))
tmpname = rinput + suffix
gscript.run_command('g.copy', raster=[rinput, tmpname])
TMPRAST.append(tmpname)
gscript.run_command('r.colors', map=tmpname, color='grey')
reg = gscript.region()
width = reg['cols']
height = reg['rows']
fg_out = os.path.join(TMPDIR, 'foreground.png')
bg_out = os.path.join(TMPDIR, 'background.png')
intensity_tmp = os.path.join(TMPDIR, 'intensity.png')
gscript.run_command('d.mon', start='cairo', output=fg_out,
width=width, height=height, bgcolor='black')
gscript.run_command('d.rast', map=rinput)
gscript.run_command('d.mon', stop='cairo')
# background
gscript.run_command('d.mon', start='cairo', output=bg_out,
width=width, height=height)
gscript.run_command('d.rast', map=background)
gscript.run_command('d.mon', stop='cairo')
# greyscale
gscript.run_command('d.mon', start='cairo', output=intensity_tmp,
width=width, height=height)
gscript.run_command('d.rast', map=tmpname)
gscript.run_command('d.mon', stop='cairo')
# put together with transparency
foreground = Image.open(fg_out)
background = Image.open(bg_out)
intensity = Image.open(intensity_tmp)
foreground = foreground.convert("RGBA")
data_f = foreground.getdata()
data_i = intensity.getdata()
newData = []
for i in range(len(data_f)):
intens = data_i[i][0]
if intens == 0:
newData.append((data_f[i][0], data_f[i][1], data_f[i][2], 0))
else:
newData.append((data_f[i][0], data_f[i][1], data_f[i][2],
scale(0, 255, intens, method)))
foreground.putdata(newData)
background.paste(foreground, (0, 0), foreground)
background.save(output)
def _reprojectMap(self):
"""!Reproject data using gdalwarp if needed
"""
# reprojection of raster
if self.proj_srs != self.proj_location: # TODO: do it better
grass.message(_("Reprojecting raster..."))
self.temp_warpmap = grass.tempfile()
if int(os.getenv('GRASS_VERBOSE', '2')) <= 2:
nuldev = file(os.devnull, 'w+')
else:
nuldev = None
if self.params['method'] == "nearest":
gdal_method = "near"
elif self.params['method'] == "linear":
gdal_method = "bilinear"
else:
gdal_method = self.params['method']
#"+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0 +k=1.0 +units=m +nadgrids=@null +no_defs"
# RGB rasters - alpha layer is added for cropping edges of projected raster
try:
if self.temp_map_bands_num == 3:
ps = grass.Popen(['gdalwarp',
'-s_srs', '%s' % self.proj_srs,
'-t_srs', '%s' % self.proj_location,
'-r', gdal_method, '-dstalpha',
self.temp_map, self.temp_warpmap], stdout = nuldev)
# RGBA rasters
else:
ps = grass.Popen(['gdalwarp',
'-s_srs', '%s' % self.proj_srs,
'-t_srs', '%s' % self.proj_location,
'-r', gdal_method,
self.temp_map, self.temp_warpmap], stdout = nuldev)
ps.wait()
except OSError as e:
grass.fatal('%s \nThis can be caused by missing %s utility. ' % (e, 'gdalwarp'))
if nuldev:
nuldev.close()
if ps.returncode != 0:
grass.fatal(_('%s failed') % 'gdalwarp')
grass.try_remove(self.temp_map)
# raster projection is same as projection of location
else:
self.temp_warpmap = self.temp_map
self.temp_files_to_cleanup.remove(self.temp_map)
return self.temp_warpmap
def save_footprints(self, map_name):
if self._products_df_sorted is None:
return
try:
from osgeo import ogr, osr
except ImportError as e:
gs.fatal(
_("Option <footprints> requires GDAL library: {}").format(e))
gs.message(_("Writing footprints into <{}>...").format(map_name))
driver = ogr.GetDriverByName("GPKG")
tmp_name = gs.tempfile() + '.gpkg'
data_source = driver.CreateDataSource(tmp_name)
srs = osr.SpatialReference()
srs.ImportFromEPSG(4326)
layer = data_source.CreateLayer(str(map_name), srs, ogr.wkbPolygon)
# attributes
attrs = OrderedDict([("uuid", ogr.OFTString),
("ingestiondate", ogr.OFTString),
("cloudcoverpercentage", ogr.OFTInteger),
("producttype", ogr.OFTString),
("identifier", ogr.OFTString)])
for key in attrs.keys():
field = ogr.FieldDefn(key, attrs[key])
layer.CreateField(field)
# features
for idx in range(len(self._products_df_sorted['uuid'])):
wkt = self._products_df_sorted['footprint'][idx]
feature = ogr.Feature(layer.GetLayerDefn())
feature.SetGeometry(ogr.CreateGeometryFromWkt(wkt))
for key in attrs.keys():
if key == 'ingestiondate':
value = self._products_df_sorted[key][idx].strftime(
"%Y-%m-%dT%H:%M:%SZ")
else:
value = self._products_df_sorted[key][idx]
feature.SetField(key, value)
layer.CreateFeature(feature)
feature = None
data_source = None
gs.run_command('v.import',
input=tmp_name,
output=map_name,
layer=map_name,
quiet=True)
def OnAddLayer(self, event):
"""Add web service layer."""
# add layer
if self.active_ws_panel is None:
return
lcmd = self.active_ws_panel.CreateCmd()
if not lcmd:
return None
# TODO: It is not clear how to do GetOptData in giface
# knowing what GetOptData is doing might help
# (maybe Get... is not the right name)
# please fix giface if you know
# tree -> giface
# GetLayerTree -> GetLayerList
# AddLayer -> AddLayer (but tree ones returns some layer,
# giface ones nothing)
# GetLayerInfo -> Layer object can by used instead
# GetOptData -> unknown
ltree = self.giface.GetLayerTree()
active_ws = self.active_ws_panel.GetWebService()
if "WMS" not in active_ws:
cap_file = self.active_ws_panel.GetCapFile()
cmd_cap_file = grass.tempfile()
shutil.copyfile(cap_file, cmd_cap_file)
lcmd.append("capfile=" + cmd_cap_file)
layer = ltree.AddLayer(
ltype="wms",
lname=self.active_ws_panel.GetOutputLayerName(),
lchecked=True,
lcmd=lcmd,
)
ws_cap_files = self._getCapFiles()
# create properties dialog
cmd_list = ltree.GetLayerInfo(layer, "cmd")
cmd = cmdlist_to_tuple(cmd_list)
prop_win = WSPropertiesDialog(
parent=self.parent,
giface=self.giface,
id=wx.ID_ANY,
layer=layer,
ws_cap_files=ws_cap_files,
cmd=cmd,
)
prop_win.Hide()
ltree.GetOptData(dcmd=None, layer=layer, params=None, propwin=prop_win)
def getEnvironment(gisdbase, location, mapset):
"""Creates environment to be passed in run_command for example.
Returns tuple with temporary file path and the environment. The user
of this function is responsile for deleting the file."""
tmp_gisrc_file = gscript.tempfile()
with open(tmp_gisrc_file, 'w') as f:
f.write('MAPSET: {mapset}\n'.format(mapset=mapset))
f.write('GISDBASE: {g}\n'.format(g=gisdbase))
f.write('LOCATION_NAME: {l}\n'.format(l=location))
f.write('GUI: text\n')
env = os.environ.copy()
env['GISRC'] = tmp_gisrc_file
return tmp_gisrc_file, env
def getEnvironment(gisdbase, location, mapset):
"""Creates environment to be passed in run_command for example.
Returns tuple with temporary file path and the environment. The user
of this function is responsile for deleting the file."""
tmp_gisrc_file = gscript.tempfile()
with open(tmp_gisrc_file, 'w') as f:
f.write('MAPSET: {mapset}\n'.format(mapset=mapset))
f.write('GISDBASE: {g}\n'.format(g=gisdbase))
f.write('LOCATION_NAME: {l}\n'.format(l=location))
f.write('GUI: text\n')
env = os.environ.copy()
env['GISRC'] = tmp_gisrc_file
return tmp_gisrc_file, env
def main():
start = options["start"]
# select = options["select"]
# stop = options["stop"]
# unlock = options["unlock"]
# create the command file
command_file = grass.tempfile()
os.system("g.gisenv set=GRASS_PYCMDFILE=%s" % command_file)
if start != "":
os.spawnlp(os.P_NOWAIT, os.environ["GRASS_PYTHON"], os.environ["GRASS_PYTHON"], "%s/etc/wxpython/gui_core/mapdisp.py" % os.environ["GISBASE"], start, command_file)
return
def create_water_surface(left_pairs, right_pairs, out_vect):
"""
Use the two lists of coordinate pairs to create a text file for import into v.in.ascii
The left coords first, then the right coords starting from the end,
in order to make a closed polygon. Starting upstream along the left side of the water surface,
to the end of the reach, then back to the start along the right side
Add the first point of the left pairs a second time to complete the boundary
"""
tmp_coords = grass.tempfile()
proc = os.getpid()
tmp_vect = out_vect + "_tmp_" + str(proc)
# How many total points in the boundary: all the right side+ left side +1
# to allow for the first point a 2nd time to close boundary
ttl_pts = len(left_pairs) + len(right_pairs) + 1
grass.message(
"Total number of vertices to be added to water surface polygon: %s" %
ttl_pts)
with open(tmp_coords, 'w') as tmp:
# Write coords in the standard ASCII file format for a grass boundary
# Loop thru the left coord pairs, then in reverse thru the right pairs
tmp.write("VERTI:\n")
tmp.write("B %s\n" % ttl_pts)
for i in range(len(left_pairs)):
tmp.write(" " + left_pairs[i][0] + " " + left_pairs[i][1] + "\n")
for j in range(len(right_pairs) - 1, -1, -1):
tmp.write(" " + right_pairs[j][0] + " " + right_pairs[j][1] + "\n")
# Finally add the first point of the left pairs again to close the boundary
tmp.write(" " + left_pairs[0][0] + " " + left_pairs[0][1] + "\n")
tmp.close()
# Now feed into v.in.ascii and also run v.centroids to make a centroid for the polygon
grass.run_command('v.in.ascii',
input=tmp_coords,
output=tmp_vect,
format="standard",
quiet=True,
overwrite=True)
grass.run_command('v.centroids',
input=tmp_vect,
output=out_vect,
quiet=True,
overwrite=True)
grass.message("Polygon vector: %s has been created" % (out_vect))
grass.message("Cleaning up tmp files %s,%s" % (str(tmp), str(tmp_vect)))
grass.run_command('g.remove', type='vect', name=tmp_vect, flags="f")
os.unlink(tmp_coords)
def create_stations_schematic(invect, outvect, spacing, cats):
"""
Loop thru all river reaches, and for each reach
begin at the downstream end of the reach,
and create a series of points at each "spacing" interval.
Put these points into an ASCII file, formatted for v.segment
and run v.segment to create a line vector of stations along the original river
"""
# Create temp file for Points
tmp_stations = grass.tempfile()
tmp = open(tmp_stations,'w')
# Keep track of how many total river stations were marked
station_cnt=0
# cats is a dict with cat as key and reach length as value
for c in cats:
reach_len=float(cats[c])
# Begins at the downstream of each river reach, and work upstream
# Each iteration creates a line segment "spacing" meters upstream of the previous
# Use the same line id for each segment in the reach
# The first station is postioned spacing/2 from the downstream end of the read
station=reach_len-(spacing/2)
pt=0
# Loop until the remaining length < spacing/2
while station>=spacing/2:
# concatenate (as strings) a point iterator with the line cat value to create a point cat
pt+=1
pt_id=c + "%03d" % pt
st1=str(math.floor(station))
tmp.write("P "+pt_id+" "+c+" "+st1+"\n")
grass.message("Adding point: %s at position:%s" % (pt_id, st1))
station -= spacing
station_cnt+=1
tmp.close()
grass.run_command('v.segment',input=invect, output=outvect, rules=tmp_stations, overwrite=True, quiet=True)
os.unlink(tmp_stations)
# Add coordinates to each station
grass.run_command('v.db.addtable', map=outvect, quiet=True)
grass.run_command('v.db.addcolumn', map=outvect, columns="x DOUBLE PRECISION, y DOUBLE PRECISION", quiet=True)
grass.run_command('v.to.db', map=outvect, option="coor", columns="x,y", quiet=True)
# Also get the reach id for each station
# The point ids are created from line (reach) cats + three more digits.
# Dividing point id by 1000 returns original line id
grass.run_command('v.db.addcolumn', map=outvect, columns="reach_id INTEGER", quiet=True)
grass.run_command('v.to.db', map=outvect, option="query", columns="reach_id", qcolumn="cat/1000", quiet=True)
return station_cnt
def main():
geojson = options['input']
outvect = options['output']
tmpfile = grass.tempfile() + ".geojson"
fd = open(tmpfile, "w")
fd.write("%s\n" % (geojson))
fd.close()
grass.run_command('v.import', input=tmpfile, output=outvect)
grass.try_remove(tmpfile)
return 0
def OnAddLayer(self, event):
"""Add web service layer.
"""
# add layer
if self.active_ws_panel is None:
return
lcmd = self.active_ws_panel.CreateCmd()
if not lcmd:
return None
# TODO: It is not clear how to do GetOptData in giface
# knowing what GetOptData is doing might help
# (maybe Get... is not the right name)
# please fix giface if you know
# tree -> giface
# GetLayerTree -> GetLayerList
# AddLayer -> AddLayer (but tree ones returns some layer,
# giface ones nothing)
# GetLayerInfo -> Layer object can by used instead
# GetOptData -> unknown
ltree = self.giface.GetLayerTree()
active_ws = self.active_ws_panel.GetWebService()
if 'WMS' not in active_ws:
cap_file = self.active_ws_panel.GetCapFile()
cmd_cap_file = grass.tempfile()
shutil.copyfile(cap_file, cmd_cap_file)
lcmd.append('capfile=' + cmd_cap_file)
layer = ltree.AddLayer(ltype = 'wms',
lname = self.active_ws_panel.GetOutputLayerName(),
lchecked = True, lcmd = lcmd)
ws_cap_files = self._getCapFiles()
# create properties dialog
cmd_list = ltree.GetLayerInfo(layer,'cmd')
cmd = CmdToTuple(cmd_list)
prop_win = WSPropertiesDialog(parent = self.parent,
giface = self.giface,
id = wx.ID_ANY,
layer = layer,
ws_cap_files = ws_cap_files,
cmd = cmd)
prop_win.Hide()
ltree.GetOptData(dcmd = None, layer = layer,
params = None, propwin = prop_win)
def _tempfile(self):
"""!Create temp_file and append list self.temp_files_to_cleanup
with path of file
@return string path to temp_file
"""
temp_file = grass.tempfile()
if temp_file is None:
grass.fatal(_("Unable to create temporary files"))
# list of created tempfiles for destructor
self.temp_files_to_cleanup.append(temp_file)
return temp_file
def clean_temp(pid):
"""Remove temporary files of the current processes
:param pid: Process ID whos tempfiles to remove
:type pid: int
"""
from pathlib import Path
from shutil import rmtree
tempfile = Path(grass.tempfile(create=False))
for path in tempfile.parent.glob(str(pid) + ".*"):
if path.is_file():
grassutils.try_rmdir(path)
else:
rmtree(path)
def process_infile(flow_file, separator, header, sameok, outputfile):
vnetinfile = gscript.tempfile()
sqlfile = gscript.tempfile()
cat = 0
with open(vnetinfile, 'w') as fout:
with open(sqlfile, 'w') as sqlout:
sqlout.write("BEGIN TRANSACTION;\n")
with open(flow_file, 'r') as fin:
for line in fin:
cat += 1
if header:
header = False
continue
data = line.rstrip().split(separator)
print(data)
if sameok or not (data[0] == data[1]):
fout.write("%s %s %s\n" % (cat, data[0], data[1]))
sqlout.write("UPDATE %s SET from_node = %s, to_node = %s, volume = %s WHERE cat = %d;\n" % (outputfile, data[0], data[1], data[2], cat))
sqlout.write("END TRANSACTION;\n")
return vnetinfile, sqlfile
def _tempfile(self):
"""!Create temp_file and append list self.temp_files_to_cleanup
with path of file
@return string path to temp_file
"""
temp_file = grass.tempfile()
if temp_file is None:
grass.fatal(_("Unable to create temporary files"))
# list of created tempfiles for destructor
self.temp_files_to_cleanup.append(temp_file)
return temp_file
def SetBaseStatistics(self, cat, name, color):
"""Sets basic (non-statistical) values.
.. todo::
Later self.name is changed but self.rasterName is not.
self.rasterName should not be set by user. It can remains
the same. But it should be done more explicitly. Currently
it looks like unintentional feature or bug.
"""
self.category = cat
self.name = name
self.color = color
rasterPath = grass.tempfile(create=False)
name = name.replace(' ', '_')
self.rasterName = name + '_' + os.path.basename(rasterPath)
def _tempfile(self):
"""!Create temp_file and append list self.temp_files_to_cleanup
with path of file
@return string path to temp_file
"""
self._debug("_tempfile", "started")
temp_file = g.tempfile()
if temp_file is None:
g.fatal(_("Unable to create temporary files"))
# list of created tempfiles for destructor
self.temp_files_to_cleanup.append(temp_file)
self._debug("_tempfile", "finished")
return temp_file
def _tempfile(self):
"""!Create temp_file and append list self.temp_files_to_cleanup
with path of file
@return string path to temp_file
"""
self._debug("_tempfile", "started")
temp_file = gscript.tempfile()
if temp_file is None:
gscript.fatal(_("Unable to create temporary files"))
# list of created tempfiles for destructor
self.temp_files_to_cleanup.append(temp_file)
self._debug("_tempfile", "finished")
return temp_file
def attributes(layer, column):
# Method that returns attribute data as a list
temp = grass.tempfile()
# ... and create and open a new file for writing with that temporary name.
layer_temp = file(temp, 'w')
# Get vector layer attribute data and write it to layer_temp
grass.run_command("v.db.select", flags="c", map=layer, columns=column, stdout = layer_temp)
layer_temp.close()
# Create a list for holding the attribute values
attlist = []
# Open the file where attribute data ise stored and write each feature attribute data into the list
layer_temp = file(temp)
for feat in layer_temp:
attlist.append(float(feat))
layer_temp.close()
return attlist
def buildRoutingNet(self):
'''Connect with subbasin centroids when subbasincentroids set to subbasins
vector (x,y will be uploaded to table)'''
# get inlets and outlets information
oinfo = vreport(self.outlets,index='subbasinID')
iinfo = vreport(self.inlets,index='inletID')
line = lambda fromxy,toxy: '%s,%s\n%s,%s\nNaN,NaN\n' %(fromxy['x'],fromxy['y'],
toxy['x'],toxy['y'])
# loop over outlets
lines=[]
manual=[]
for oID in oinfo:
# inlet ID of outlet or downstream subbasin
sbinletID=int(oinfo[oID]['inletID'])
# for manually changed subbasins or outlets
if sbinletID==0:
if int(oinfo[oID]['nextID'])>0: manual+=[oinfo[oID]]
continue
# from outlets to inlets
lines+=[line(oinfo[oID],iinfo[sbinletID])]
gm('Connected %s outlets' %len(oinfo))
# connect centroids with outlets and inlets with centroids if -c flag set
# get subbasin centroids
sbinfo = vreport(self.subbasins,index='subbasinID')
# from centroids to outlets
for o in oinfo:
lines+=[line(sbinfo[o],oinfo[o])]
# from inlets to centroids
for i in iinfo:
# get subbasinId of inlet
insb = int(iinfo[i]['subbasinID'])
lines+=[line(iinfo[i],sbinfo[insb])]
# connect outlets with centroids of nextID for all manually changed subbasins
for sb in manual:
lines+=line(oinfo[int(sb['subbasinID'])],sbinfo[int(sb['nextID'])])
# write to tmpfile and read as lines
tf=grass.tempfile()
f=file(tf,'w')
f.writelines(lines)
f.close()
# make line vector
grun('v.in.lines',input=tf,output=self.routingnet,separator=',',quiet=True)
return
def getEnvironment(gisdbase, location, mapset):
"""Creates environment to be passed in run_command for example.
Returns tuple with temporary file path and the environment. The user
of this function is responsile for deleting the file."""
tmp_gisrc_file = gscript.tempfile()
with open(tmp_gisrc_file, 'w') as f:
f.write('MAPSET: {mapset}\n'.format(mapset=mapset))
f.write('GISDBASE: {g}\n'.format(g=gisdbase))
f.write('LOCATION_NAME: {l}\n'.format(l=location))
f.write('GUI: text\n')
env = os.environ.copy()
env['GISRC'] = tmp_gisrc_file
env['GRASS_REGION'] = gscript.region_env(raster='elevation_2004@PERMANENT')
env['GRASS_OVERWRITE'] = '1'
env['GRASS_VERBOSE'] = '0'
env['GRASS_MESSAGE_FORMAT'] = 'standard'
return tmp_gisrc_file, env
def getEnvironment(gisdbase, location, mapset):
"""Creates an environment to be passed in run_command.
Returns a tuple with a temporary file path and an environment.
The user should delete this temporary file."""
tmp_gisrc_file = gscript.tempfile()
with open(tmp_gisrc_file, 'w') as f:
f.write('MAPSET: {mapset}\n'.format(mapset=mapset))
f.write('GISDBASE: {g}\n'.format(g=gisdbase))
f.write('LOCATION_NAME: {l}\n'.format(l=location))
f.write('GUI: text\n')
env = os.environ.copy()
env['GISRC'] = tmp_gisrc_file
env['GRASS_REGION'] = gscript.region_env(raster=region, res=res)
env['GRASS_OVERWRITE'] = '1'
env['GRASS_VERBOSE'] = '0'
env['GRASS_MESSAGE_FORMAT'] = 'standard'
return tmp_gisrc_file, env
def __init__(self, parent, giface, layer, ws_cap_files, cmd, id=wx.ID_ANY,
style=wx.DEFAULT_DIALOG_STYLE | wx.RESIZE_BORDER, **kwargs):
"""
:param giface: grass interface
:param layer: layer tree item
:param ws_cap_files: dict web service('WMS_1.1.1', 'WMS_1.3.0',
'WMTS', 'OnEarth') : cap file path cap files, which will be parsed
:param cmd: cmd to which dialog widgets will be initialized if
it is possible (cmp parameters exists in parsed web service cap_file)
"""
WSDialogBase.__init__(
self,
parent,
id=wx.ID_ANY,
style=wx.DEFAULT_DIALOG_STYLE | wx.RESIZE_BORDER,
**kwargs)
self.SetTitle(_("Web service layer properties"))
self.layer = layer
self.giface = giface
# after web service panels are connected, set dialog widgets
# according to cmd in this variable (if it is not None)
self.cmd_to_set = None
# store data needed for reverting
self.revert_ws_cap_files = {}
self.revert_cmd = cmd
ws_cap = self._getWSfromCmd(cmd)
for ws in self.ws_panels.iterkeys():
# cap file used in cmd will be deleted, thnaks to the dialogs
# destructor
if ws == ws_cap and 'capfile' in cmd[1]:
self.revert_ws_cap_files[ws] = cmd[1]['capfile']
del ws_cap_files[ws]
else:
self.revert_ws_cap_files[ws] = grass.tempfile()
self._setRevertCapFiles(ws_cap_files)
self.LoadCapFiles(ws_cap_files=self.revert_ws_cap_files, cmd=cmd)
self.btn_ok.SetDefault()
def AddCategory(self, cat_id):
cat_id = ScattPlotsCondsData.AddCategory(self, cat_id)
if cat_id < 0:
return cat_id
for scatt_id in self.scatts_ids:
ScattPlotsCondsData.AddScattPlot(self, cat_id, scatt_id)
if cat_id == 0:
self.cats_rasts_conds[cat_id] = None
self.cats_rasts[cat_id] = None
else:
self.cats_rasts_conds[cat_id] = grass.tempfile()
self.cats_rasts[cat_id] = "temp_cat_rast_%d_%d" % (cat_id, os.getpid())
region = self.an_data.GetRegion()
CreateCatRast(region, self.cats_rasts_conds[cat_id])
return cat_id
def main():
global tmp_img, tmp_grad_abs, tmp_grad_rel
os.environ['GRASS_OVERWRITE'] = '1'
color_dir = os.path.join(os.environ['GISBASE'], "etc", "colors")
output_dir = os.path.join(os.environ['GISBASE'], "docs", "html")
if not os.path.exists(output_dir):
os.makedirs(output_dir)
pid = os.getpid()
tmp_grad_abs = "tmp_grad_abs_%d" % pid
tmp_grad_rel = "tmp_grad_rel_%d" % pid
tmp_img = grass.tempfile() + ".ppm"
os.environ['GRASS_RENDER_WIDTH'] = '%d' % width
os.environ['GRASS_RENDER_HEIGHT'] = '%d' % height
os.environ['GRASS_RENDER_FRAME'] = '%f,%f,%f,%f' % (0,height,0,width)
os.environ['GRASS_RENDER_FILE'] = tmp_img
os.environ['GRASS_RENDER_TRUECOLOR'] = 'TRUE'
os.environ['GRASS_RENDER_FILE_READ'] = 'FALSE'
os.environ['GRASS_RENDER_FILE_MAPPED'] = 'FALSE'
os.environ['GRASS_RENDER_TRANSPARENT'] = 'FALSE'
os.environ['GRASS_RENDER_BACKGROUNDCOLOR'] = 'ffffff'
os.environ['GRASS_RENDER_IMMEDIATE'] = 'cairo'
for var in ['GRASS_RENDER_LINE_WIDTH', 'GRASS_RENDER_ANTIALIAS']:
if var in os.environ:
del os.environ[var]
grass.use_temp_region()
grass.run_command('g.region', rows = 100, cols = 100)
grass.mapcalc("$grad = row()/1.0", grad = tmp_grad_rel, quiet = True)
for table in os.listdir(color_dir):
path = os.path.join(color_dir, table)
grad = make_gradient(path)
make_image(output_dir, table, grad)
grass.mapcalc("$grad = row()", grad = tmp_grad_abs, quiet = True)
for table in ['grey.eq', 'grey.log', 'random']:
make_image(output_dir, table, tmp_grad_abs, True)
def OnConnect(self, event):
"""!Connect to the server"""
server = self.server.GetValue()
if not server:
self.btn_import.Enable(False)
return # not reachable
layers = {}
ret = RunCommand('r.in.wms2',
quiet = True,
parent = self,
wms_version = "1.3.0",
read = True,
flags = 'c',
mapserver = server)
temp_file = grass.tempfile()
if temp_file is None:
grass.fatal(_("Unable to create temporary files"))##TOFO
temp = open(temp_file, "w")
temp.write(ret.encode('utf-8'))#TODO
temp.close()
if not ret:
self.list.LoadData()
self.btn_import.Enable(False)
return # no layers found
try:
self.cap = WMSCapabilities(temp_file)
except GException as error:
GError(error, parent = self)
# update list of layers
self.list.LoadData(self.cap)
if len(layers.keys()) > 0:
self.btn_import.Enable(True)
else:
self.btn_import.Enable(False)
def create_water_surface(left_pairs, right_pairs, out_vect):
"""
Use the two lists of coordinate pairs to create a text file for import into v.in.ascii
The left coords first, then the right coords starting from the end,
in order to make a closed polygon. Starting upstream along the left side of the water surface,
to the end of the reach, then back to the start along the right side
Add the first point of the left pairs a second time to complete the boundary
"""
tmp_coords = grass.tempfile()
proc=os.getpid()
tmp_vect = out_vect+"_tmp_"+str(proc)
# How many total points in the boundary: all the right side+ left side +1
# to allow for the first point a 2nd time to close boundary
ttl_pts = len(left_pairs)+len(right_pairs)+1
grass.message("Total number of vertices to be added to water surface polygon: %s" % ttl_pts)
with open(tmp_coords,'w') as tmp:
# Write coords in the standard ASCII file format for a grass boundary
# Loop thru the left coord pairs, then in reverse thru the right pairs
tmp.write("VERTI:\n")
tmp.write("B %s\n" % ttl_pts)
for i in range(len(left_pairs)):
tmp.write(" "+left_pairs[i][0]+" "+left_pairs[i][1]+"\n")
for j in range(len(right_pairs)-1, -1, -1):
tmp.write(" "+right_pairs[j][0]+" "+right_pairs[j][1]+"\n")
# Finally add the first point of the left pairs again to close the boundary
tmp.write(" "+left_pairs[0][0]+" "+left_pairs[0][1]+"\n")
tmp.close()
# Now feed into v.in.ascii and also run v.centroids to make a centroid for the polygon
grass.run_command('v.in.ascii',input=tmp_coords, output=tmp_vect, format="standard",
quiet=True, overwrite=True)
grass.run_command('v.centroids', input=tmp_vect, output=out_vect, quiet=True, overwrite=True)
grass.message("Polygon vector: %s has been created" % (out_vect))
grass.message("Cleaning up tmp files %s,%s" %(str(tmp), str(tmp_vect)))
grass.run_command('g.remove',type='vect', name=tmp_vect, flags="f")
os.unlink(tmp_coords)
def main():
global tmp
tmp = grass.tempfile()
vector = options['map']
layer = options['layer']
column = options['column']
where = options['where']
perc = options['percentile']
extend = flags['e']
shellstyle = flags['g']
if not grass.find_file(vector, element='vector')['file']:
grass.fatal(_("Vector map <%s> not found") % vector)
try:
fi = grass.vector_db(vector, stderr = nuldev)[int(layer)]
except KeyError:
grass.fatal(_("No attribute table linked to layer <%s>") % layer)
table = fi['table']
database = fi['database']
driver = fi['driver']
passflags = None
if flags['e']:
passflags = 'e'
if flags['g']:
if not passflags:
passflags = 'g'
else:
passflags = passflags + 'g'
try:
grass.run_command('db.univar', table = table, column = column,
database = database, driver = driver,
perc = perc, where = where, flags = passflags)
except CalledModuleError:
sys.exit(1)
def rreclass(in_raster, in_list, out_list, proper=True):
"""Reclass a GRASS raster map from via an in list and outlist \n
Patches together the rules, writes it to file, performs r.reclass,
deletes in_raster and rules file and renames the outraster"""
# temporary rules file
temp_rules = grass.tempfile()
# put lists in easy writable numpy array
rules = np.array((in_list, out_list)).transpose()
# write rules to file
np.savetxt(temp_rules, rules, delimiter='=', fmt='%i')
# reclass raster in grass
grun('r.reclass', input=in_raster,
overwrite=True, quiet=True,
output=in_raster + '__',
rules=temp_rules)
# make reclassed raster a proper raster, remove in_rast and rename output
if proper:
grass.mapcalc('__temp=' + in_raster + '__', quiet=True)
grun('g.remove', type='rast', name=in_raster + '__,' + in_raster,
flags='f', quiet=True)
grun('g.rename', rast='__temp,' + in_raster, quiet=True)
return
def initialize(self):
grass.use_temp_region()
run('g.region', raster = self.inmap)
reg = grass.region()
for k, f in wind_keys.values():
self.total[k] = (f)(reg[k])
if self.cols > self.total['cols']:
self.cols = self.total['cols']
if self.rows > self.total['rows']:
self.rows = self.total['rows']
tempbase = grass.tempfile()
grass.try_remove(tempbase)
self.tempfile = tempbase + '.ppm'
self.tempmap = 'tmp.d.rast.edit'
atexit.register(self.cleanup)
run('g.copy', raster = (self.inmap, self.outmap), overwrite = True)
run('r.colors', map = self.outmap, rast = self.inmap)
def OnRun(self, event):
"""Run Python script"""
if not self.filename:
self.filename = gscript.tempfile() + '.py'
self.tempfile = True
try:
fd = open(self.filename, "w")
fd.write(self.body.GetText())
except IOError as e:
GError(_("Unable to launch Python script. %s") % e,
parent=self.guiparent)
return
finally:
fd.close()
mode = stat.S_IMODE(os.lstat(self.filename)[stat.ST_MODE])
os.chmod(self.filename, mode | stat.S_IXUSR)
else:
# always save automatically before running
fd = open(self.filename, "w")
try:
fd.write(self.body.GetText())
finally:
fd.close()
# set executable file
# (not sure if needed every time but useful for opened files)
os.chmod(self.filename, stat.S_IRWXU | stat.S_IWUSR)
# run in console as other modules, avoid Python shell which
# carries variables over to the next execution
env = os.environ.copy()
if self.overwrite:
env['GRASS_OVERWRITE'] = '1'
cmd = [fd.name]
if self.parameters:
cmd.extend(self.parameters)
self.giface.RunCmd(cmd, env=env)
