def __init__(self, ltype, cmd, Map, name=None,
active=True, hidden=False, opacity=1.0, mapfile=None, render=True):
"""Create new instance
.. todo::
pass cmd as tuple instead of list
:param ltype: layer type ('raster', 'vector', 'overlay', 'command', etc.)
:param cmd: GRASS command to render layer, given as list,
e.g. ['d.rast', 'map=elevation@PERMANENT']
:param map: render.Map instance
:param name: layer name, e.g. 'elevation@PERMANENT' (for layer tree)
:param active: layer is active, will be rendered only if True
:param hidden: layer is hidden, won't be listed in Layer Manager if True
:param float opacity: layer opacity <0;1>
:param mapfile full path to output file or None
"""
if mapfile:
self.mapfile = mapfile
else:
if ltype == 'overlay':
tempfile_sfx = ".png"
else:
tempfile_sfx = ".ppm"
mapfile = tempfile.NamedTemporaryFile(suffix=tempfile_sfx, delete=False)
# we don't want it open, we just need the name
self.mapfile = mapfile.name
mapfile.close()
os.remove(self.mapfile) # remove empty file
self.maskfile = self.mapfile.rsplit(".",1)[0] + ".pgm"
# stores class which manages rendering instead of simple command - e.g. WMS
self.renderMgr = None
self.Map = Map
self.type = None
self.SetType(ltype)
self.name = name
if self.type == 'command':
self.cmd = list()
for c in cmd:
self.cmd.append(cmdlist_to_tuple(c))
else:
self.cmd = cmdlist_to_tuple(cmd)
self.active = active
self.hidden = hidden
self.opacity = opacity
self.forceRender = render
Debug.msg (3, "Layer.__init__(): type=%s, cmd='%s', name=%s, " \
"active=%d, opacity=%d, hidden=%d" % \
(self.type, self.GetCmd(string=True), self.name,
self.active, self.opacity, self.hidden))
def SetCmd(self, cmd):
"""Set new command for layer"""
if self.type == 'command':
self.cmd = []
for c in cmd:
self.cmd.append(cmdlist_to_tuple(c))
else:
self.cmd = cmdlist_to_tuple(cmd)
Debug.msg(3, "Layer.SetCmd(): cmd='%s'" % self.GetCmd(string = True))
# for re-rendering
self.forceRender = True
def SetCmd(self, cmd):
"""Set new command for layer"""
if self.type == 'command':
self.cmd = []
for c in cmd:
self.cmd.append(cmdlist_to_tuple(c))
else:
self.cmd = cmdlist_to_tuple(cmd)
Debug.msg(3, "Layer.SetCmd(): cmd='%s'" % self.GetCmd(string=True))
# for re-rendering
self.forceRender = True
def AddRenderLayer(self, cmd=None, colorsCmd=None):
"""Add map from map window layers to render """
if not self.mapWin:
return False
existsMap = grass.find_file(name=self.fullName,
element='vector',
mapset=grass.gisenv()['MAPSET'])
if not existsMap["name"]:
self.DeleteRenderLayer()
return False
if not cmd:
cmd = []
cmd.insert(0, 'd.vect')
cmd.append('map=%s' % self.fullName)
if self.renderLayer:
self.DeleteRenderLayer()
if colorsCmd:
colorsCmd.append('map=%s' % self.fullName)
layerStyleVnetColors = cmdlist_to_tuple(colorsCmd)
RunCommand(layerStyleVnetColors[0],
**layerStyleVnetColors[1])
self.renderLayer = self.mapWin.Map.AddLayer(
ltype="vector", command=cmd, name=self.fullName, active=True,
opacity=1.0, render=False, pos=-1)
return True
def LoadOverlay(self, cmd):
"""Creates raster legend with d.legend
:param cmd: d.legend command as a list
:return: bitmap with legend
"""
Debug.msg(5, "BitmapProvider.LoadOverlay: cmd={c}".format(c=cmd))
fileHandler, filename = tempfile.mkstemp(suffix=".png")
os.close(fileHandler)
# Set the environment variables for this process
_setEnvironment(self.imageWidth, self.imageHeight, filename,
transparent=True, bgcolor=(0, 0, 0))
Debug.msg(1, "Render raster legend " + str(filename))
cmdTuple = cmdlist_to_tuple(cmd)
returncode, stdout, messages = read2_command(
cmdTuple[0], **cmdTuple[1])
if returncode == 0:
return wx.BitmapFromImage(autoCropImageFromFile(filename))
else:
os.remove(filename)
raise GException(messages)
def RenderProcess3D(imageWidth, imageHeight, tempDir, cmd, region, bgcolor, fileQueue):
"""Renders image with m.nviz.image and writes the
resulting ppm filename in the provided file queue
:param imageWidth: image width
:param imageHeight: image height
:param tempDir: directory for rendering
:param cmd: m.nviz.image command as a list
:param region: region as a dict
:param bgcolor: background color as a tuple of 3 values 0 to 255
:param fileQueue: the inter process communication queue
storing the file name of the image
"""
filename = GetFileFromCmd(tempDir, cmd, None)
os.environ['GRASS_REGION'] = gcore.region_env(region3d=True, **region)
Debug.msg(1, "Render image to file " + str(filename))
cmdTuple = cmdlist_to_tuple(cmd)
cmdTuple[1]['output'] = os.path.splitext(filename)[0]
# set size
cmdTuple[1]['size'] = '%d,%d' % (imageWidth, imageHeight)
# set format
cmdTuple[1]['format'] = 'ppm'
cmdTuple[1]['bgcolor'] = bgcolor = ':'.join([str(part) for part in bgcolor])
returncode, stdout, messages = read2_command(cmdTuple[0], **cmdTuple[1])
if returncode != 0:
gcore.warning("Rendering failed:\n" + messages)
fileQueue.put(None)
os.environ.pop('GRASS_REGION')
return
os.environ.pop('GRASS_REGION')
fileQueue.put(filename)
def RenderProcess2D(imageWidth, imageHeight, tempDir, cmd, region, bgcolor, fileQueue):
"""Render raster or vector files as ppm image and write the
resulting ppm filename in the provided file queue
:param imageWidth: image width
:param imageHeight: image height
:param tempDir: directory for rendering
:param cmd: d.rast/d.vect command as a list
:param region: region as a dict or None
:param bgcolor: background color as a tuple of 3 values 0 to 255
:param fileQueue: the inter process communication queue
storing the file name of the image
"""
filename = GetFileFromCmd(tempDir, cmd, region)
transparency = True
# Set the environment variables for this process
_setEnvironment(imageWidth, imageHeight, filename,
transparent=transparency, bgcolor=bgcolor)
if region:
os.environ['GRASS_REGION'] = gcore.region_env(**region)
cmdTuple = cmdlist_to_tuple(cmd)
returncode, stdout, messages = read2_command(cmdTuple[0], **cmdTuple[1])
if returncode != 0:
gcore.warning("Rendering failed:\n" + messages)
fileQueue.put(None)
if region:
os.environ.pop('GRASS_REGION')
os.remove(filename)
return
if region:
os.environ.pop('GRASS_REGION')
fileQueue.put(filename)
def LoadOverlay(self, cmd):
"""Creates raster legend with d.legend
:param cmd: d.legend command as a list
:return: bitmap with legend
"""
Debug.msg(5, "BitmapProvider.LoadOverlay: cmd={c}".format(c=cmd))
fileHandler, filename = tempfile.mkstemp(suffix=".png")
os.close(fileHandler)
# Set the environment variables for this process
_setEnvironment(
self.imageWidth,
self.imageHeight,
filename,
transparent=True,
bgcolor=(0, 0, 0),
)
Debug.msg(1, "Render raster legend " + str(filename))
cmdTuple = cmdlist_to_tuple(cmd)
returncode, stdout, messages = read2_command(cmdTuple[0],
**cmdTuple[1])
if returncode == 0:
return BitmapFromImage(autoCropImageFromFile(filename))
else:
os.remove(filename)
raise GException(messages)
def GetCommand(self):
if not self.task:
return None
self.task.set_flag('overwrite', True)
self.task.set_param('output', 'tobechanged')
cmd = self.task.get_cmd(ignoreErrors=False, ignoreRequired=False, ignoreDefault=True)
return gtask.cmdlist_to_tuple(cmd)
def RenderProcess3D(imageWidth, imageHeight, tempDir, cmd, region, bgcolor, fileQueue):
"""Renders image with m.nviz.image and writes the
resulting ppm filename in the provided file queue
:param imageWidth: image width
:param imageHeight: image height
:param tempDir: directory for rendering
:param cmd: m.nviz.image command as a list
:param region: region as a dict
:param bgcolor: background color as a tuple of 3 values 0 to 255
:param fileQueue: the inter process communication queue
storing the file name of the image
"""
filename = GetFileFromCmd(tempDir, cmd, None)
os.environ["GRASS_REGION"] = gcore.region_env(region3d=True, **region)
Debug.msg(1, "Render image to file " + str(filename))
cmdTuple = cmdlist_to_tuple(cmd)
cmdTuple[1]["output"] = os.path.splitext(filename)[0]
# set size
cmdTuple[1]["size"] = "%d,%d" % (imageWidth, imageHeight)
# set format
cmdTuple[1]["format"] = "ppm"
cmdTuple[1]["bgcolor"] = bgcolor = ":".join([str(part) for part in bgcolor])
returncode, stdout, messages = read2_command(cmdTuple[0], **cmdTuple[1])
if returncode != 0:
gcore.warning("Rendering failed:\n" + messages)
fileQueue.put(None)
os.environ.pop("GRASS_REGION")
return
os.environ.pop("GRASS_REGION")
fileQueue.put(filename)
def GetCommand(self):
if not self.task:
return None
self.task.set_flag('overwrite', True)
self.task.set_param('output', 'tobechanged')
cmd = self.task.get_cmd(ignoreErrors=False,
ignoreRequired=False,
ignoreDefault=True)
return gtask.cmdlist_to_tuple(cmd)
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 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 _apply(self):
"""Apply chosen values from widgets to web service layer."""
lcmd = self.active_ws_panel.CreateCmd()
if not lcmd:
return
active_ws = self.active_ws_panel.GetWebService()
if "WMS" not in active_ws:
lcmd.append("capfile=" + self.revert_ws_cap_files[active_ws])
self.giface.GetLayerTree().GetOptData(
dcmd=lcmd, layer=self.layer, params=True, propwin=self
)
# TODO use just list or tuple
cmd = cmdlist_to_tuple(lcmd)
self.revert_cmd = cmd
self._setRevertCapFiles(self._getCapFiles())
self.giface.updateMap.emit()
def _apply(self):
"""Apply chosen values from widgets to web service layer."""
lcmd = self.active_ws_panel.CreateCmd()
if not lcmd:
return
active_ws = self.active_ws_panel.GetWebService()
if 'WMS' not in active_ws:
lcmd.append('capfile=' + self.revert_ws_cap_files[active_ws])
self.giface.GetLayerTree().GetOptData(dcmd=lcmd,
layer=self.layer,
params=None,
propwin=self)
# TODO use just list or tuple
cmd = cmdlist_to_tuple(lcmd)
self.revert_cmd = cmd
self._setRevertCapFiles(self._getCapFiles())
self.giface.updateMap.emit()
def RenderProcess2D(imageWidth, imageHeight, tempDir, cmd, region, bgcolor,
fileQueue):
"""Render raster or vector files as ppm image and write the
resulting ppm filename in the provided file queue
:param imageWidth: image width
:param imageHeight: image height
:param tempDir: directory for rendering
:param cmd: d.rast/d.vect command as a list
:param region: region as a dict or None
:param bgcolor: background color as a tuple of 3 values 0 to 255
:param fileQueue: the inter process communication queue
storing the file name of the image
"""
filename = GetFileFromCmd(tempDir, cmd, region)
transparency = True
# Set the environment variables for this process
_setEnvironment(imageWidth,
imageHeight,
filename,
transparent=transparency,
bgcolor=bgcolor)
if region:
os.environ["GRASS_REGION"] = gcore.region_env(**region)
cmdTuple = cmdlist_to_tuple(cmd)
returncode, stdout, messages = read2_command(cmdTuple[0], **cmdTuple[1])
if returncode != 0:
gcore.warning("Rendering failed:\n" + messages)
fileQueue.put(None)
if region:
os.environ.pop("GRASS_REGION")
os.remove(filename)
return
if region:
os.environ.pop("GRASS_REGION")
fileQueue.put(filename)
def AddRenderLayer(self, cmd=None, colorsCmd=None):
"""Add map from map window layers to render """
if not self.mapWin:
return False
existsMap = grass.find_file(
name=self.fullName, element="vector", mapset=grass.gisenv()["MAPSET"]
)
if not existsMap["name"]:
self.DeleteRenderLayer()
return False
if not cmd:
cmd = []
cmd.insert(0, "d.vect")
cmd.append("map=%s" % self.fullName)
if self.renderLayer:
self.DeleteRenderLayer()
if colorsCmd:
colorsCmd.append("map=%s" % self.fullName)
layerStyleVnetColors = cmdlist_to_tuple(colorsCmd)
RunCommand(layerStyleVnetColors[0], **layerStyleVnetColors[1])
self.renderLayer = self.mapWin.Map.AddLayer(
ltype="vector",
command=cmd,
name=self.fullName,
active=True,
opacity=1.0,
render=False,
pos=-1,
)
return True
def SaveTmpLayer(self, layer_name):
"""Permanently saves temporary map of analysis result"""
msg = _("Vector map with analysis result does not exist.")
if not hasattr(self.results["vect_map"], "GetVectMapName"):
GMessage(parent=self.guiparent, message=msg)
return
mapToAdd = self.results["vect_map"].GetVectMapName()
mapToAddEx = grass.find_file(name=mapToAdd,
element='vector',
mapset=grass.gisenv()['MAPSET'])
if not mapToAddEx["name"]:
GMessage(parent=self.guiparent, message=msg)
return
addedMap = layer_name
mapName, mapSet = ParseMapStr(addedMap)
if mapSet != grass.gisenv()['MAPSET']:
GMessage(
parent=self.guiparent,
message=_("Map can be saved only to currently set mapset"))
return
existsMap = grass.find_file(name=mapName,
element='vector',
mapset=grass.gisenv()['MAPSET'])
if existsMap["name"]:
dlg = wx.MessageDialog(parent=self.guiparent,
message=_("Vector map %s already exists. " +
"Do you want to overwrite it?") %
(existsMap["fullname"]),
caption=_("Overwrite vector map"),
style=wx.YES_NO | wx.NO_DEFAULT
| wx.ICON_QUESTION | wx.CENTRE)
ret = dlg.ShowModal()
if ret == wx.ID_NO:
dlg.Destroy()
return
dlg.Destroy()
RunCommand("g.copy",
overwrite=True,
vector=[self.results["vect_map"].GetVectMapName(), mapName])
if len(self.giface.GetLayerList().GetLayersByName(mapName)) == 0:
# TODO: get rid of insert
cmd, cmd_colors = self.vnet_data.GetLayerStyle()
cmd.insert(0, 'd.vect')
cmd.append('map=%s' % mapName)
self.giface.GetLayerList().AddLayer(ltype="vector",
name=mapName,
cmd=cmd,
checked=True)
if cmd_colors:
layerStyleVnetColors = cmdlist_to_tuple(cmd_colors)
RunCommand(layerStyleVnetColors[0], **layerStyleVnetColors[1])
else:
self.giface.updateMap.emit(render=True, renderVector=True)
def __init__(self,
ltype,
cmd,
Map,
name=None,
active=True,
hidden=False,
opacity=1.0,
mapfile=None,
render=True):
"""Create new instance
.. todo::
pass cmd as tuple instead of list
:param ltype: layer type ('raster', 'vector', 'overlay', 'command', etc.)
:param cmd: GRASS command to render layer, given as list,
e.g. ['d.rast', 'map=elevation@PERMANENT']
:param map: render.Map instance
:param name: layer name, e.g. 'elevation@PERMANENT' (for layer tree)
:param active: layer is active, will be rendered only if True
:param hidden: layer is hidden, won't be listed in Layer Manager if True
:param float opacity: layer opacity <0;1>
:param mapfile full path to output file or None
"""
if mapfile:
self.mapfile = mapfile
else:
if ltype == 'overlay':
tempfile_sfx = ".png"
else:
tempfile_sfx = ".ppm"
mapfile = tempfile.NamedTemporaryFile(suffix=tempfile_sfx,
delete=False)
# we don't want it open, we just need the name
self.mapfile = mapfile.name
mapfile.close()
os.remove(self.mapfile) # remove empty file
self.maskfile = self.mapfile.rsplit(".", 1)[0] + ".pgm"
# stores class which manages rendering instead of simple command - e.g. WMS
self.renderMgr = None
self.Map = Map
self.type = None
self.SetType(ltype)
self.name = name
if self.type == 'command':
self.cmd = list()
for c in cmd:
self.cmd.append(cmdlist_to_tuple(c))
else:
self.cmd = cmdlist_to_tuple(cmd)
self.active = active
self.hidden = hidden
self.opacity = opacity
self.forceRender = render
Debug.msg (3, "Layer.__init__(): type=%s, cmd='%s', name=%s, " \
"active=%d, opacity=%d, hidden=%d" % \
(self.type, self.GetCmd(string=True), self.name,
self.active, self.opacity, self.hidden))
def GetLayersFromCmdFile(self):
"""Get list of map layers from cmdfile
"""
if not self.cmdfile:
return
nlayers = 0
try:
fd = open(self.cmdfile, 'r')
lines = fd.readlines()
fd.close()
# detect d.out.file, delete the line from the cmd file and export
# graphics
if len(lines) > 0:
if lines[-1].startswith('d.out.file') or \
lines[-1].startswith('d.to.rast'):
dCmd = lines[-1].strip()
fd = open(self.cmdfile, 'w')
fd.writelines(lines[:-1])
fd.close()
if lines[-1].startswith('d.out.file'):
self.saveToFile.emit(cmd=utils.split(dCmd))
else:
self.dToRast.emit(cmd=utils.split(dCmd))
return
if lines[-1].startswith('d.what'):
dWhatCmd = lines[-1].strip()
fd = open(self.cmdfile, 'w')
fd.writelines(lines[:-1])
fd.close()
if '=' in utils.split(dWhatCmd)[1]:
maps = utils.split(dWhatCmd)[1].split('=')[1].split(
',')
else:
maps = utils.split(dWhatCmd)[1].split(',')
self.query.emit(
ltype=utils.split(dWhatCmd)[0].split('.')[-1],
maps=maps)
return
else:
# clean overlays after erase
self.oldOverlays = []
overlays = list(
self._giface.GetMapDisplay().decorations.keys())
for each in overlays:
self._giface.GetMapDisplay().RemoveOverlay(each)
existingLayers = self.GetListOfLayers()
# holds new rendreing order for every layer in existingLayers
layersOrder = [-1] * len(existingLayers)
# next number in rendering order
next_layer = 0
mapFile = None
render_env = dict()
for line in lines:
if line.startswith('#'):
if 'GRASS_RENDER_FILE' in line:
mapFile = line.split('=', 1)[1].strip()
try:
k, v = line[2:].strip().split('=', 1)
except:
pass
render_env[k] = v
continue
cmd = utils.split(line.strip())
ltype = None
try:
ltype = utils.command2ltype[cmd[0]]
except KeyError:
grass.warning(_("Unsupported command %s.") % cmd[0])
continue
name = utils.GetLayerNameFromCmd(cmd,
fullyQualified=True,
layerType=ltype)[0]
args = {}
if ltype in ('barscale', 'rastleg', 'northarrow', 'text',
'vectleg'):
# TODO: this is still not optimal
# it is there to prevent adding the same overlay multiple times
if cmd in self.oldOverlays:
continue
if ltype == 'rastleg':
self._giface.GetMapDisplay().AddLegendRast(cmd=cmd)
elif ltype == 'barscale':
self._giface.GetMapDisplay().AddBarscale(cmd=cmd)
elif ltype == 'northarrow':
self._giface.GetMapDisplay().AddArrow(cmd=cmd)
elif ltype == 'text':
self._giface.GetMapDisplay().AddDtext(cmd=cmd)
elif ltype == 'vectleg':
self._giface.GetMapDisplay().AddLegendVect(cmd=cmd)
self.oldOverlays.append(cmd)
continue
classLayer = MapLayer
args['ltype'] = ltype
exists = False
for i, layer in enumerate(existingLayers):
if layer.GetCmd(string=True) == utils.GetCmdString(
cmdlist_to_tuple(cmd)):
exists = True
if layersOrder[i] == -1:
layersOrder[i] = next_layer
next_layer += 1
# layer must be put higher in render order (same cmd was insered more times)
# TODO delete rendurant cmds from cmd file?
else:
for j, l_order in enumerate(layersOrder):
if l_order > layersOrder[i]:
layersOrder[j] -= 1
layersOrder[i] = next_layer - 1
break
if exists:
continue
mapLayer = classLayer(name=name,
cmd=cmd,
Map=None,
hidden=True,
render=False,
mapfile=mapFile,
**args)
mapLayer.GetRenderMgr().updateProgress.connect(
self.GetRenderMgr().ReportProgress)
if render_env:
mapLayer.GetRenderMgr().UpdateRenderEnv(render_env)
render_env = dict()
newLayer = self._addLayer(mapLayer)
existingLayers.append(newLayer)
self.ownedLayers.append(newLayer)
layersOrder.append(next_layer)
next_layer += 1
nlayers += 1
reorderedLayers = [-1] * next_layer
for i, layer in enumerate(existingLayers):
# owned layer was not found in cmd file -> is deleted
if layersOrder[i] == -1 and layer in self.ownedLayers:
self.ownedLayers.remove(layer)
self.DeleteLayer(layer)
# other layer e. g. added by wx.vnet are added to the top
elif layersOrder[i] == -1 and layer not in self.ownedLayers:
reorderedLayers.append(layer)
# owned layer found in cmd file is added into proper rendering
# position
else:
reorderedLayers[layersOrder[i]] = layer
self.SetLayers(reorderedLayers)
except IOError as e:
grass.warning(
_("Unable to read cmdfile '%(cmd)s'. Details: %(det)s") % {
'cmd': self.cmdfile,
'det': e
})
return
Debug.msg(
1, "Map.GetLayersFromCmdFile(): cmdfile=%s, nlayers=%d" %
(self.cmdfile, nlayers))
self._giface.updateMap.emit(render=False)
def SaveTmpLayer(self, layer_name):
"""Permanently saves temporary map of analysis result"""
msg = _("Vector map with analysis result does not exist.")
if not hasattr(self.results["vect_map"], "GetVectMapName"):
GMessage(parent=self.guiparent,
message=msg)
return
mapToAdd = self.results["vect_map"].GetVectMapName()
mapToAddEx = grass.find_file(name=mapToAdd,
element='vector',
mapset=grass.gisenv()['MAPSET'])
if not mapToAddEx["name"]:
GMessage(parent=self.guiparent,
message=msg)
return
addedMap = layer_name
mapName, mapSet = ParseMapStr(addedMap)
if mapSet != grass.gisenv()['MAPSET']:
GMessage(parent=self.guiparent, message=_(
"Map can be saved only to currently set mapset"))
return
existsMap = grass.find_file(name=mapName,
element='vector',
mapset=grass.gisenv()['MAPSET'])
if existsMap["name"]:
dlg = wx.MessageDialog(parent=self.guiparent,
message=_("Vector map %s already exists. " +
"Do you want to overwrite it?") %
(existsMap["fullname"]),
caption=_("Overwrite vector map"),
style=wx.YES_NO | wx.NO_DEFAULT |
wx.ICON_QUESTION | wx.CENTRE)
ret = dlg.ShowModal()
if ret == wx.ID_NO:
dlg.Destroy()
return
dlg.Destroy()
RunCommand("g.copy",
overwrite=True,
vector=[self.results["vect_map"].GetVectMapName(), mapName])
if len(self.giface.GetLayerList().GetLayersByName(mapName)) == 0:
# TODO: get rid of insert
cmd, cmd_colors = self.vnet_data.GetLayerStyle()
cmd.insert(0, 'd.vect')
cmd.append('map=%s' % mapName)
self.giface.GetLayerList().AddLayer(ltype="vector",
name=mapName,
cmd=cmd,
checked=True)
if cmd_colors:
layerStyleVnetColors = cmdlist_to_tuple(cmd_colors)
RunCommand(layerStyleVnetColors[0],
**layerStyleVnetColors[1])
else:
self.giface.updateMap.emit(render=True, renderVector=True)
