def __init__(self, guiparent, giface):
self.data = {}
self.guiparent = guiparent
self.giface = giface
self.mapWin = giface.GetMapWindow()
self.goutput = GConsole(guiparent=guiparent)
self.vnet_data = VNETData(guiparent=guiparent, mapWin=self.mapWin)
self.results = {"analysis": None, "vect_map": None} #TODO more results
# this class instance manages all temporary vector maps created during life of VNETDialog
self.tmp_maps = VNETTmpVectMaps(parent=guiparent, mapWin=self.mapWin)
# initialization of History class used for saving and reading data from file
# it is used for browsing analysis results
self.history = VNETHistory(self.guiparent, self.vnet_data,
self.tmp_maps)
self.analyses = VNETAnalyses(self.vnet_data, self.RunAnDone,
self.goutput, self.tmp_maps)
self.snap_nodes = SnappingNodes(self.giface, self.vnet_data,
self.tmp_maps, self.mapWin)
self.ttbCreated = Signal('VNETManager.ttbCreated')
self.analysisDone = Signal('VNETManager.analysisDone')
self.pointsChanged = self.vnet_data.pointsChanged
self.parametersChanged = self.vnet_data.parametersChanged
self.snapping = self.snap_nodes.snapping
self.pointsChanged.connect(self.PointsChanged)
class VNETManager:
def __init__(self, guiparent, giface):
self.data = {}
self.guiparent = guiparent
self.giface = giface
self.mapWin = giface.GetMapWindow()
self.goutput = GConsole(guiparent=guiparent)
self.vnet_data = VNETData(guiparent=guiparent, mapWin=self.mapWin)
self.results = {
"analysis": None,
"vect_map": None
} # TODO more results
# this class instance manages all temporary vector maps created during
# life of VNETDialog
self.tmp_maps = VNETTmpVectMaps(parent=guiparent, mapWin=self.mapWin)
# initialization of History class used for saving and reading data from file
# it is used for browsing analysis results
self.history = VNETHistory(self.guiparent, self.vnet_data,
self.tmp_maps)
self.analyses = VNETAnalyses(self.vnet_data, self.RunAnDone,
self.goutput, self.tmp_maps)
self.snap_nodes = SnappingNodes(self.giface, self.vnet_data,
self.tmp_maps, self.mapWin)
self.ttbCreated = Signal('VNETManager.ttbCreated')
self.analysisDone = Signal('VNETManager.analysisDone')
self.pointsChanged = self.vnet_data.pointsChanged
self.parametersChanged = self.vnet_data.parametersChanged
self.snapping = self.snap_nodes.snapping
self.pointsChanged.connect(self.PointsChanged)
def __del__(self):
self.CleanUp()
def CleanUp(self):
"""Removes temp layers, unregisters handlers and graphics"""
update = self.tmp_maps.DeleteAllTmpMaps()
self.vnet_data.CleanUp()
if update:
self.giface.updateMap.emit(render=True, renderVector=True)
else:
self.giface.updateMap.emit(render=False, renderVector=False)
def GetPointsManager(self):
return self.vnet_data.GetPointsData()
def GetGlobalTurnsData(self):
return self.vnet_data.GetGlobalTurnsData()
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 RunAnDone(self, cmd, returncode, results):
self.results["analysis"] = cmd[0]
self.results["vect_map"].SaveVectMapState()
cmd, cmd_colors = self.vnet_data.GetLayerStyle()
self.results["vect_map"].AddRenderLayer(cmd, cmd_colors)
self.history.SaveHistStep()
self.analysisDone.emit()
def ShowResult(self, show):
# TODO can be more results e. g. smallest cut
if show:
self._checkResultMapChanged(self.results["vect_map"])
cmd, cmd_colors = self.vnet_data.GetLayerStyle()
self.results["vect_map"].AddRenderLayer(cmd, cmd_colors)
else:
self.results["vect_map"].DeleteRenderLayer()
self.giface.updateMap.emit(render=True, renderVector=True)
def GetAnalysisProperties(self, analysis=None):
return self.vnet_data.GetAnalysisProperties(analysis=analysis)
def GetResults(self):
return self.results["vect_map"]
def Undo(self):
self._updateDataForHistStep(self.history.Undo())
# SetUpdateMap TODO
return self.history.GetHistStep()
def Redo(self):
self._updateDataForHistStep(self.history.Redo())
# SetUpdateMap
return self.history.GetHistStep()
def _updateDataForHistStep(self, data):
if not data:
return
analysis, resultMapName, params, flags = data
self.results["analysis"] = analysis
self.vnet_data.SetParams(params, flags)
self.results["vect_map"].DeleteRenderLayer()
self.results["vect_map"] = self.tmp_maps.GetTmpVectMap(resultMapName)
self._checkResultMapChanged(self.results["vect_map"])
cmd, cmd_colors = self.vnet_data.GetLayerStyle()
self.results["vect_map"].AddRenderLayer(cmd, cmd_colors)
self.giface.updateMap.emit(render=True, renderVector=True)
def GetHistStep(self):
return self.history.GetHistStep()
def SetParams(self, params, flags):
self.vnet_data.SetParams(params, flags)
def GetParams(self):
params, inv_params, flags = self.vnet_data.GetParams()
return params, inv_params, flags
def GetParam(self, param):
return self.vnet_data.GetParam(param)
def _checkResultMapChanged(self, resultVectMap):
"""Check if map was modified outside"""
if resultVectMap.VectMapState() == 0:
dlg = wx.MessageDialog(
parent=self,
message=_("Temporary map '%s' with result " +
"was changed outside vector network analysis tool.\n"
+ "Showed result may not correspond " +
"original analysis result.") %
resultVectMap.GetVectMapName(),
caption=_("Result changed outside"),
style=wx.ICON_INFORMATION | wx.CENTRE)
dlg.ShowModal()
dlg.Destroy()
def IsSnappingActive(self):
return self.vnet_data.GetSnapping()
def Snapping(self, activate):
self.snap_nodes.ComputeNodes(activate)
def GetAnalyses(self):
return self.vnet_data.GetAnalyses()
def SettingsUpdated(self):
self.vnet_data.GetPointsData().SetPointDrawSettings()
if not self.results["vect_map"] or not self.tmp_maps.HasTmpVectMap(
self.results["vect_map"].GetVectMapName()):
self.giface.updateMap.emit(render=False, renderVector=False)
elif self.results["vect_map"].GetRenderLayer():
cmd, cmd_colors = self.vnet_data.GetLayerStyle()
self.results["vect_map"].AddRenderLayer(cmd, cmd_colors)
self.giface.updateMap.emit(render=True, renderVector=True)
# TODO optimization
else:
self.giface.updateMap.emit(render=False, renderVector=False)
def PointsChanged(self, method, kwargs):
self.giface.updateMap.emit(render=False, renderVector=False)
def CreateTttb(self, params):
outputMap = params["output"]
mapName, mapSet = ParseMapStr(outputMap)
if mapSet != grass.gisenv()['MAPSET']:
GMessage(parent=self,
message=_("Map can be created only in current mapset"))
return False
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()
dlg.Destroy()
if ret == wx.ID_NO:
return False
cmdTtb = [
"v.net.turntable",
"input=" + params["input"],
"output=" + params["output"],
"arc_layer=" + params["arc_layer"],
"turn_layer=" + params["turn_layer"],
"turn_cat_layer=" + params["turn_cat_layer"],
"--overwrite",
]
self.goutput.RunCmd(command=cmdTtb, onDone=self._createTtbDone)
return True
def _createTtbDone(self, event):
if event.returncode != 0:
GMessage(parent=self.guiparent,
message=_("Creation of turntable failed."))
return
else:
params = {}
for c in event.cmd:
spl_c = c.split("=")
if len(spl_c) != 2:
continue
if spl_c[0] and spl_c != "input":
params[spl_c[0]] = spl_c[1]
if spl_c[0] == "output":
params["input"] = spl_c[1]
self.vnet_data.SetParams(params, {})
self.ttbCreated.emit(returncode=event.returncode)
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)