def OnMCalcRun(self, event):
"""Builds and runs r.mapcalc statement
"""
name = self.newmaptxt.GetValue().strip()
if not name:
GError(parent=self,
message=_("You must enter the name of "
"a new raster map to create."))
return
if not(name[0] == '"' and name[-1] == '"') and any((char in name)
for char in self.charactersToQuote):
name = '"' + name + '"'
expr = self.text_mcalc.GetValue().strip().replace("\n", " ")
if not expr:
GError(parent=self,
message=_("You must enter an expression "
"to create a new raster map."))
return
seed_flag = seed = None
if re.search(pattern="rand *\(.+\)", string=expr):
if self.randomSeed.IsChecked():
seed_flag = '-s'
else:
seed = self.randomSeedText.GetValue().strip()
if self.log:
cmd = [self.cmd]
if seed_flag:
cmd.append('-s')
if seed:
cmd.append("seed={val}".format(val=seed))
if self.overwrite.IsChecked():
cmd.append('--overwrite')
cmd.append(str('expression=%s = %s' % (name, expr)))
self.log.RunCmd(cmd, onDone=self.OnDone)
self.parent.Raise()
else:
if self.overwrite.IsChecked():
overwrite = True
else:
overwrite = False
params = dict(expression="%s=%s" % (name, expr),
overwrite=overwrite)
if seed_flag:
params['flags'] = 's'
if seed:
params['seed'] = seed
RunCommand(self.cmd,
**params)
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 CleanUp(self):
ScattPlotsCondsData.CleanUp(self)
for tmp in self.cats_rasts_conds.itervalues():
grass.try_remove(tmp)
for tmp in self.cats_rasts.itervalues():
RunCommand("g.remove", flags='f',
type='raster', name=tmp,
getErrorMsg=True)
self.cats_rasts = {}
self.cats_rasts_conds = {}
def test():
nviz = NvizTask('/home/anna/testy/nviz/t12.gxw')
# nviz = NvizState('/home/anna/testy/nviz/t3.gxw')
# cmd = nviz.GetCommand()
cmds = nviz.GetCommandSeries(['aspect', 'elevation'], 'color_map')
for cmd in cmds:
print cmd
returncode, message = RunCommand(getErrorMsg=True,
prog=cmd[0],
**cmd[1])
print returncode, message
def DeleteCategory(self, cat_id):
ScattPlotsCondsData.DeleteCategory(self, cat_id)
grass.try_remove(self.cats_rasts_conds[cat_id])
del self.cats_rasts_conds[cat_id]
RunCommand("g.remove", flags='f', type='raster',
name=self.cats_rasts[cat_id])
del self.cats_rasts[cat_id]
return True
def _estimateResampling(self):
output = RunCommand('r.info',
flags='g',
quiet=False,
read=True,
map=self.iLayer,
env=self.iEnv,
parse=parse_key_val)
if output['datatype'] == 'CELL':
self.resampling.SetStringSelection('nearest')
else:
self.resampling.SetStringSelection('bilinear')
def writeArea(self, coords, rasterName):
polyfile = tempfile.NamedTemporaryFile(delete=False)
polyfile.write("AREA\n")
for coor in coords:
east, north = coor
point = " %s %s\n" % (east, north)
polyfile.write(point)
catbuf = "=%d a\n" % self.catId
polyfile.write(catbuf)
self.catId = self.catId + 1
polyfile.close()
region_settings = grass.parse_command('g.region', flags='p',
delimiter=':')
pname = polyfile.name.split('/')[-1]
tmpraster = "rast_" + pname
tmpvector = "vect_" + pname
wx.BeginBusyCursor()
wx.GetApp().Yield()
RunCommand('r.in.poly', input=polyfile.name, output=tmpraster,
rows=region_settings['rows'], overwrite=True)
RunCommand('r.to.vect', input=tmpraster, output=tmpvector,
type='area', overwrite=True)
RunCommand('v.to.rast', input=tmpvector, output=rasterName,
value=1, use='val')
wx.EndBusyCursor()
grass.use_temp_region()
grass.run_command('g.region', vector=tmpvector)
region = grass.region()
marea = MaskedArea(region, rasterName)
RunCommand('g.remove', flags='f', type='raster', name=tmpraster)
RunCommand('g.remove', flags='f', type='vector', name=tmpvector)
os.unlink(polyfile.name)
return marea
def switch_mapset_interactively(guiparent, giface, dbase, location, mapset):
"""Switch current mapset. Emits giface.currentMapsetChanged signal."""
if dbase:
if RunCommand('g.mapset',
parent=guiparent,
location=location,
mapset=mapset,
dbase=dbase) == 0:
GMessage(parent=guiparent,
message=_("Current GRASS database is <%(dbase)s>.\n"
"Current location is <%(loc)s>.\n"
"Current mapset is <%(mapset)s>.") % {
'dbase': dbase,
'loc': location,
'mapset': mapset
})
giface.currentMapsetChanged.emit(dbase=dbase,
location=location,
mapset=mapset)
elif location:
if RunCommand('g.mapset',
parent=guiparent,
location=location,
mapset=mapset) == 0:
GMessage(parent=guiparent,
message=_("Current location is <%(loc)s>.\n"
"Current mapset is <%(mapset)s>.") % {
'loc': location,
'mapset': mapset
})
giface.currentMapsetChanged.emit(dbase=None,
location=location,
mapset=mapset)
else:
if RunCommand('g.mapset', parent=guiparent, mapset=mapset) == 0:
GMessage(parent=guiparent,
message=_("Current mapset is <%s>.") % mapset)
giface.currentMapsetChanged.emit(dbase=None,
location=None,
mapset=mapset)
def OnUninstall(self, event):
"""Uninstall selected extensions"""
eList = self._getSelectedExtensions()
if not eList:
return
for ext in eList:
files = RunCommand('g.extension',
parent=self,
read=True,
quiet=True,
extension=ext,
operation='remove').splitlines()
if len(files) > 10:
files = files[:10]
files.append('...')
dlg = wx.MessageDialog(
parent=self,
message=_(
"List of files to be removed:\n%(files)s\n\n"
"Do you want really to remove <%(ext)s> extension?") % {
'files': os.linesep.join(files),
'ext': ext
},
caption=_("Remove extension"),
style=wx.YES_NO | wx.NO_DEFAULT | wx.ICON_QUESTION)
if dlg.ShowModal() == wx.ID_YES:
RunCommand('g.extension',
flags='f',
parent=self,
quiet=True,
extension=ext,
operation='remove')
self.extList.LoadData()
# update prompt
globalvar.UpdateGRASSAddOnCommands(eList)
toolboxesOutdated()
def _geomAttrbUpdate(self, fids):
"""Update geometry atrributes of currently selected features
:param fid: list feature id
"""
mapLayer = self.parent.toolbars["vdigit"].GetLayer()
vectorName = mapLayer.GetName()
if self.tree:
item = self.tree.FindItemByData("maplayer", mapLayer)
vdigit = self.tree.GetLayerInfo(item, key="vdigit")
else:
item = vdigit = None
if not vdigit or "geomAttr" not in vdigit:
return
dbInfo = gselect.VectorDBInfo(vectorName)
sqlfile = tempfile.NamedTemporaryFile(mode="w")
for fid in fids:
for layer, cats in six.iteritems(self.digit.GetLineCats(fid)):
table = dbInfo.GetTable(layer)
for attrb, item in six.iteritems(vdigit["geomAttr"]):
val = -1
if attrb == "length":
val = self.digit.GetLineLength(fid)
type = attrb
elif attrb == "area":
val = self.digit.GetAreaSize(fid)
type = attrb
elif attrb == "perimeter":
val = self.digit.GetAreaPerimeter(fid)
type = "length"
if val < 0:
continue
val = UnitsConvertValue(val, type, item["units"])
for cat in cats:
sqlfile.write(
"UPDATE %s SET %s = %f WHERE %s = %d;\n" % (
table,
item["column"],
val,
dbInfo.GetKeyColumn(layer),
cat,
))
sqlfile.file.flush()
RunCommand("db.execute",
parent=True,
quiet=True,
input=sqlfile.name)
def _rasterize(self, grass_region, layer, cat, out_rast):
# TODO different thread may be problem when user edits map
environs = os.environ.copy()
environs['GRASS_VECTOR_TEMPORARY'] = '1'
ret, text, msg = RunCommand("v.category",
input=self.vectMap,
getErrorMsg=True,
option='report',
read=True,
env=environs)
ret, text, msg = RunCommand("v.build",
map=self.vectMap,
getErrorMsg=True,
read=True,
env=environs)
if ret != 0:
GException(_("v.build failed:\n%s" % msg))
environs = os.environ.copy()
environs["GRASS_REGION"] = grass_region["GRASS_REGION"]
environs['GRASS_VECTOR_TEMPORARY'] = '1'
ret, text, msg = RunCommand("v.to.rast",
input=self.vectMap,
use="cat",
layer=str(layer),
cat=str(cat),
output=out_rast,
getErrorMsg=True,
read=True,
overwrite=True,
env=environs)
if ret != 0:
GException(_("v.to.rast failed:\n%s" % msg))
def ComputeStatitistics(self):
"""!Computes statistics for raster map using 'r.univar' module.
@return statistic in form of dictionary
"""
# RunCommand enables to run GRASS module
res = RunCommand(
'r.univar', # module name
flags='g', # command flags
map=self.currentRaster, # module parameters
read=True) # get command output
return gcore.parse_key_val(res, val_type=float)
def rename(self):
"""Rename layer"""
if self.selected_layer and self.new_name:
string = self.old_name + ',' + self.new_name
self.ChangeEnvironment(self.GetItemText(self.selected_location),
self.GetItemText(self.selected_mapset))
renamed = 0
label = _("Renaming") + " " + string + " ..."
self.showNotification.emit(message=label)
if (self.GetItemText(self.selected_type) == 'vect'):
renamed = RunCommand('g.rename', vect=string)
elif (self.GetItemText(self.selected_type) == 'rast'):
renamed = RunCommand('g.rename', rast=string)
else:
renamed = RunCommand('g.rename', rast3d=string)
if (renamed == 0):
self.SetItemText(self.selected_layer, self.new_name)
label = "g.rename " + self.GetItemText(
self.selected_type) + "=" + string + " -- completed"
self.showNotification.emit(message=label)
Debug.msg(1, "LAYER RENAMED TO: " + self.new_name)
self.RestoreBackup()
def GroupSet(self, group, subgroup):
kwargs = {}
if subgroup:
kwargs['subgroup'] = subgroup
res = RunCommand('i.group',
flags='g',
group=group,
read=True, **kwargs).strip()
if res.splitlines()[0]:
bands = res.splitlines()
self.scatt_mgr.SetBands(bands)
def GetGroupBands(self, group, subgroup):
"""Get list of raster bands which are in the soubgroup of group with both having same name."""
kwargs = {}
if subgroup:
kwargs["subgroup"] = subgroup
res = RunCommand("i.group", flags="g", group=group, read=True, **kwargs).strip()
bands = None
if res.split("\n")[0]:
bands = res.split("\n")
return bands
def ImportFile(self, filePath):
"""Tries to import file as vector or raster.
If successfull sets default region from imported map.
"""
RunCommand('db.connect', flags='c')
mapName = os.path.splitext(os.path.basename(filePath))[0]
vectors = RunCommand('v.in.ogr', input=filePath, flags='l', read=True)
wx.BeginBusyCursor()
wx.GetApp().Yield()
if vectors:
# vector detected
returncode, error = RunCommand('v.in.ogr',
input=filePath,
output=mapName,
flags='e',
getErrorMsg=True)
else:
returncode, error = RunCommand('r.in.gdal',
input=filePath,
output=mapName,
flags='e',
getErrorMsg=True)
wx.EndBusyCursor()
if returncode != 0:
GError(parent=self,
message=_("Import of <%(name)s> failed.\n"
"Reason: %(msg)s") % ({
'name': filePath,
'msg': error
}))
else:
GMessage(message=_(
"Data file <%(name)s> imported successfully. "
"The location's default region was set from this imported map."
) % {'name': filePath},
parent=self)
def Load(self, url, full=True):
"""Load list of extensions"""
self._emptyTree()
if full:
flags = 'g'
else:
flags = 'l'
retcode, ret, msg = RunCommand(
'g.extension', read=True, getErrorMsg=True, url=url, flags=flags, quiet=True)
if retcode != 0:
raise GException(_("Unable to load extensions. %s") % msg)
currentNode = None
for line in ret.splitlines():
if full:
try:
key, value = line.split('=', 1)
except ValueError:
key = 'name'
value = line
if key == 'name':
try:
prefix, name = value.split('.', 1)
except ValueError:
prefix = ''
name = value
mainNode = self.mainNodes[self._expandPrefix(prefix)]
currentNode = self.model.AppendNode(
parent=mainNode, label=value)
currentNode.data = {'command': value}
else:
if currentNode is not None:
currentNode.data[key] = value
else:
try:
prefix, name = line.strip().split('.', 1)
except ValueError:
prefix = ''
name = line.strip()
if self._expandPrefix(prefix) == prefix:
prefix = ''
module = prefix + '.' + name
mainNode = self.mainNodes[self._expandPrefix(prefix)]
currentNode = self.model.AppendNode(
parent=mainNode, label=module)
currentNode.data = {'command': module,
'keywords': '',
'description': ''}
def CreateDatalist(self, rpair):
"""Build a list of cell value, frequency pairs for histogram
frequency can be in cell counts, percents, or area
"""
datalist = []
if self.scattertype == "bubble":
freqflag = "cn"
else:
freqflag = "n"
try:
ret = RunCommand(
"r.stats",
parent=self,
input="%s,%s" % rpair,
flags=freqflag,
nsteps=self.bins,
sep=",",
quiet=True,
read=True,
)
if not ret:
return datalist
for line in ret.splitlines():
rast1, rast2 = line.strip().split(",")
rast1 = rast1.strip()
if "-" in rast1:
if rast1[0] == "-":
rast1 = "-" + rast1.split("-")[1]
else:
rast1 = rast1.split("-")[0]
rast2 = rast2.strip()
if "-" in rast2:
if rast2[0] == "-":
rast2 = "-" + rast2.split("-")[1]
else:
rast2 = rast2.split("-")[0]
rast1 = rast1.encode("ascii", "ignore")
rast2 = rast2.encode("ascii", "ignore")
datalist.append((rast1, rast2))
return datalist
except GException as e:
GError(parent=self, message=e.value)
return None
def RunAnalysis(self):
analysis, valid = self.vnet_data.GetParam("analysis")
params, err_params, flags = self.vnet_data.GetParams()
relevant_params = self.vnet_data.GetRelevantParams(analysis)
if not relevant_params:
return -1
if not self.vnet_data.InputsErrorMsgs(
_("Unable to perform analysis."),
analysis,
params,
flags,
err_params,
relevant_params,
):
return -2
if self.results["vect_map"]:
self.results["vect_map"].DeleteRenderLayer()
# history - delete data in buffer for hist step
self.history.DeleteNewHistStepData()
# create new map (included to history) for result of analysis
self.results["vect_map"] = self.history.NewTmpVectMapToHist(
"vnet_tmp_result")
if not self.results["vect_map"]:
return False
# for case there is some map with same name
# (when analysis does not produce any map, this map would have been shown as result)
RunCommand(
"g.remove",
flags="f",
type="vector",
name=self.results["vect_map"].GetVectMapName(),
)
# save data from
self.history._saveAnInputToHist(analysis, params, flags)
ret = self.analyses.RunAnalysis(
self.results["vect_map"].GetVectMapName(), params, flags)
if not ret:
return -3
else:
return 1
def ReadEpsgCodes():
"""Read EPSG codes with g.proj
:return: dictionary of EPSG code
"""
epsgCodeDict = dict()
ret = RunCommand("g.proj", read=True, list_codes="EPSG")
for line in ret.splitlines():
code, descr, params = line.split("|")
epsgCodeDict[int(code)] = (descr, params)
return epsgCodeDict
def _updateTtbByGlobalCosts(self, vectMapName, tlayer):
# TODO get layer number do not use it directly
intervals = self.turnsData["global"].GetData()
cmdUpdGlob = [
"v.db.update",
"map=",
self.inputData["input"].GetValue(),
"layer=%d" % tlayer,
"column=cost",
]
dbInfo = VectorDBInfo(vectMapName)
table = dbInfo.GetTable(tlayer)
driver, database = dbInfo.GetDbSettings(tlayer)
sqlFile = grass.tempfile()
sqlFile_f = open(sqlFile, "w")
for ival in intervals:
from_angle = ival[0]
to_angle = ival[1]
cost = ival[2]
if to_angle < from_angle:
to_angle = math.pi * 2 + to_angle
# if angle < from_angle:
# angle = math.pi * 2 + angle
where = " WHERE (((angle < {0}) AND ({2} + angle >= {0} AND {2} + angle < {1})) OR \
((angle >= {0}) AND (angle >= {0} AND angle < {1}))) AND cost==0.0 ".format(
str(from_angle), str(to_angle), str(math.pi * 2))
stm = ("UPDATE %s SET cost=%f " % (table, cost)) + where + ";\n"
sqlFile_f.write(stm)
sqlFile_f.close()
# TODO improve parser and run in thread
ret, msg, err = RunCommand(
"db.execute",
getErrorMsg=True,
input=sqlFile,
read=True,
driver=driver,
database=database,
)
try_remove(sqlFile)
def CreateDatalist(self, rpair):
"""Build a list of cell value, frequency pairs for histogram
frequency can be in cell counts, percents, or area
"""
datalist = []
if self.scattertype == 'bubble':
freqflag = 'cn'
else:
freqflag = 'n'
try:
ret = RunCommand("r.stats",
parent=self,
input='%s,%s' % rpair,
flags=freqflag,
nsteps=self.bins,
sep=',',
quiet=True,
read=True)
if not ret:
return datalist
for line in ret.splitlines():
rast1, rast2 = line.strip().split(',')
rast1 = rast1.strip()
if '-' in rast1:
if rast1[0] == '-':
rast1 = '-' + rast1.split('-')[1]
else:
rast1 = rast1.split('-')[0]
rast2 = rast2.strip()
if '-' in rast2:
if rast2[0] == '-':
rast2 = '-' + rast2.split('-')[1]
else:
rast2 = rast2.split('-')[0]
rast1 = rast1.encode('ascii', 'ignore')
rast2 = rast2.encode('ascii', 'ignore')
datalist.append((rast1, rast2))
return datalist
except GException as e:
GError(parent=self,
message=e.value)
return None
def _runCommand(self, cmd):
"""!Run command to render data
"""
if self.type == 'wms':
ret = 0
msg = ''
self.renderMgr.Render(cmd)
else:
ret, msg = RunCommand(cmd[0],
getErrorMsg=True,
quiet=True,
**cmd[1])
return ret, msg
def _estimateResolution(self):
output = RunCommand('r.proj',
flags='g',
quiet=False,
read=True,
input=self.iLayer,
dbase=self.iGisdbase,
location=self.iLocation,
mapset=self.iMapset,
env=self.oEnv).strip()
params = parse_key_val(output, vsep=' ')
output = RunCommand('g.region',
flags='ug',
quiet=False,
read=True,
env=self.oEnv,
parse=lambda x: parse_key_val(x, val_type=float),
**params)
cell_ns = (output['n'] - output['s']) / output['rows']
cell_ew = (output['e'] - output['w']) / output['cols']
estimate = (cell_ew + cell_ns) / 2.
self.resolution.SetValue(str(estimate))
self.params = params
def main():
app = wx.App()
dlg = MapsetAccess(parent=None)
dlg.CenterOnScreen()
if dlg.ShowModal() == wx.ID_OK:
ms = dlg.GetMapsets()
RunCommand("g.mapsets",
parent=None,
mapset="%s" % ",".join(ms),
operation="set")
dlg.Destroy()
def _estimateResampling(self):
output = RunCommand(
"r.info",
flags="g",
quiet=False,
read=True,
map=self.iLayer,
env=self.iEnv,
parse=parse_key_val,
)
if output["datatype"] == "CELL":
self.resampling.SetStringSelection("nearest")
else:
self.resampling.SetStringSelection("bilinear")
def main():
app = wx.App()
dlg = MapsetAccess(parent=None)
dlg.CenterOnScreen()
if dlg.ShowModal() == wx.ID_OK:
ms = dlg.GetMapsets()
RunCommand('g.mapsets',
parent=None,
mapset='%s' % ','.join(ms),
operation='set')
dlg.Destroy()
def OnDelete(self, event):
"""Delete layer or mapset"""
if (self.selected_layer):
string = self.GetItemText(self.selected_layer)
self.ChangeEnvironment(self.GetItemText(self.selected_location),
self.GetItemText(self.selected_mapset))
removed = 0
# TODO: rewrite this that it will tell map type in the dialog
if (self._confirmDialog(question=_(
'Do you really want to delete map <{m}>?').format(
m=string),
title=_('Delete map')) == wx.ID_YES):
label = _("Deleting") + " " + string + " ..."
self.showNotification.emit(message=label)
if (self.GetItemText(self.selected_type) == 'vect'):
removed = RunCommand('g.remove',
flags='f',
type='vect',
pattern=string)
elif (self.GetItemText(self.selected_type) == 'rast'):
removed = RunCommand('g.remove',
flags='f',
type='rast',
pattern=string)
else:
removed = RunCommand('g.remove',
flags='f',
type='rast3d',
pattern=string)
if (removed == 0):
self.Delete(self.selected_layer)
Debug.msg(1, "LAYER " + string + " DELETED")
label = "g.remove -f type=" + self.GetItemText(
self.selected_type
) + " pattern=" + string + " -- completed" # generate this message (command) automatically?
self.showNotification.emit(message=label)
self.RestoreBackup()
def OnCleaningRun(self, event):
"""Builds options and runs v.clean
"""
self.GetCmdStrings()
err = list()
for p, name in ((self.inmap, _('Name of input vector map')),
(self.outmap, _('Name for output vector map')),
(self.tools_string, _('Tools')), (self.thresh_string,
_('Threshold'))):
if not p:
err.append(_("'%s' not defined") % name)
if err:
GError(_("Some parameters not defined. Operation "
"canceled.\n\n%s") % '\n'.join(err),
parent=self)
return
self.SetStatusText(_("Executing selected cleaning operations..."))
snum = len(self.toolslines.keys())
if self.log:
cmd = [
self.cmd,
'input=%s' % self.inmap,
'output=%s' % self.outmap,
'tool=%s' % self.tools_string,
'thres=%s' % self.thresh_string
]
if self.ftype_string:
cmd.append('type=%s' % self.ftype_string)
if self.overwrite.IsChecked():
cmd.append('--overwrite')
self.log.RunCmd(cmd, onDone=self.OnDone)
self.parent.Raise()
else:
if self.overwrite.IsChecked():
overwrite = True
else:
overwrite = False
RunCommand(self.cmd,
input=self.inmap,
output=self.outmap,
type=self.ftype_string,
tool=self.tools_string,
thresh=self.thresh_string,
overwrite=overwrite)
def OnSetButton(self, event=None):
"""Set default region"""
ret = RunCommand('g.region',
flags='sa',
n=self.north,
s=self.south,
e=self.east,
w=self.west,
nsres=self.nsres,
ewres=self.ewres,
t=self.top,
b=self.bottom,
tbres=self.tbres)
if ret == 0:
self.Destroy()
