wxGUI/vnet: update to new parameter names (https://trac.osgeo.org/grass/ticket/2409)

git-svn-id: https://svn.osgeo.org/grass/grass/trunk@63736 15284696-431f-4ddb-bdfa-cd5b030d7da7

gui/wxpython/vnet/dialogs.py

@@ -321,13 +321,13 @@ class VNETDialog(wx.Dialog):
         label = {}
         dataSelects = [
                         ['input', "Choose vector map for analysis:", Select],
-                        ['alayer', "Arc layer number or name:", LayerSelect],
-                        ['nlayer', "Node layer number or name:", LayerSelect],
-                        #['tlayer', "Layer with turntable:", LayerSelect],
-                        #['tuclayer', "Layer with unique categories for turntable:", LayerSelect],
-                        ['afcolumn', "", ColumnSelect],
-                        ['abcolumn', "", ColumnSelect],
-                        ['ncolumn',  "", ColumnSelect],
+                        ['arc_layer', "Arc layer number or name:", LayerSelect],
+                        ['node_layer', "Node layer number or name:", LayerSelect],
+                        #['turn_layer', "Layer with turntable:", LayerSelect],
+                        #['turn_cat_layer', "Layer with unique categories for turntable:", LayerSelect],
+                        ['arc_column', "", ColumnSelect],
+                        ['arc_backward_column', "", ColumnSelect],
+                        ['node_column',  "", ColumnSelect],
                       ]
 
         #self.useTurns = wx.CheckBox(parent = dataPanel, id=wx.ID_ANY,
@@ -351,7 +351,7 @@ class VNETDialog(wx.Dialog):
                 self.addToTreeBtn.Disable()
                 self.addToTreeBtn.Bind(wx.EVT_BUTTON, self.OnToTreeBtn)
             elif dataSel[0] != 'input':
-                #if dataSel[0] == "tlayer":
+                #if dataSel[0] == "turn_layer":
                 #    self.createTtbBtn = wx.Button(parent = selPanels[dataSel[0]], 
                 #                                 label = _("Create turntable")) 
                 #    self.createTtbBtn.Bind(wx.EVT_BUTTON, self.OnCreateTtbBtn)
@@ -363,10 +363,10 @@ class VNETDialog(wx.Dialog):
             label[dataSel[0]].SetLabel(dataSel[1])
 
         self.inputData['input'].Bind(wx.EVT_TEXT, self.OnVectSel) 
-        self.inputData['alayer'].Bind(wx.EVT_TEXT, self.OnALayerSel)
-        self.inputData['nlayer'].Bind(wx.EVT_TEXT, self.OnNLayerSel)
+        self.inputData['arc_layer'].Bind(wx.EVT_TEXT, self.OnALayerSel)
+        self.inputData['node_layer'].Bind(wx.EVT_TEXT, self.OnNLayerSel)
 
-        for params in ["afcolumn", "abcolumn", "ncolumn"]:#, "tlayer", "tuclayer"]:
+        for params in ["arc_column", "arc_backward_column", "node_column"]:#, "turn_layer", "turn_cat_layer"]:
             self.inputData[params].Bind(wx.EVT_TEXT, lambda event : self._setInputData())
 
         #self.useTurns.Bind(wx.EVT_CHECKBOX,
@@ -381,14 +381,14 @@ class VNETDialog(wx.Dialog):
         mainSizer.Add(item = bsizer, proportion = 0,
                       flag = wx.EXPAND  | wx.TOP | wx.LEFT | wx.RIGHT, border = 5) 
 
-        for sel in ['input', 'alayer', 'nlayer']:#, 'tlayer', 'tuclayer']:
+        for sel in ['input', 'arc_layer', 'node_layer']:#, 'turn_layer', 'turn_cat_layer']:
             if sel == 'input':
                 btn = self.addToTreeBtn
-            #elif sel == "tlayer":
+            #elif sel == "turn_layer":
             #    btn = self.createTtbBtn
             else:
                 btn = None
-            #if sel == 'tlayer':
+            #if sel == 'turn_layer':
             #    bsizer.Add(item = self.useTurns, proportion = 0,
             #                flag = wx.TOP | wx.LEFT | wx.RIGHT, border = 5)                       
 
@@ -404,7 +404,7 @@ class VNETDialog(wx.Dialog):
         mainSizer.Add(item = bsizer, proportion = 0,
                                  flag = wx.EXPAND  | wx.TOP | wx.LEFT | wx.RIGHT, border = 5)       
 
-        for sel in ['afcolumn', 'abcolumn', 'ncolumn']:
+        for sel in ['arc_column', 'arc_backward_column', 'node_column']:
             selPanels[sel].SetSizer(self._doSelLayout(title = label[sel], sel = self.inputData[sel]))
             bsizer.Add(item = selPanels[sel], proportion = 0,
                        flag = wx.EXPAND)
@@ -531,7 +531,7 @@ class VNETDialog(wx.Dialog):
             wx.BeginBusyCursor()
             self.inpDbMgrData['dbMgr'].ChangeVectorMap(vectorName = inpSel)
             self.inpDbMgrData['input'] = inpSel
-            for layerName in ['alayer', 'nlayer']:
+            for layerName in ['arc_layer', 'node_layer']:
                 try:
                     layer = int(self.inputData[layerName].GetValue())
                 except ValueError:
@@ -542,7 +542,7 @@ class VNETDialog(wx.Dialog):
         else:
             needLayers = []
             browseLayers = self.inpDbMgrData['browse'].GetAddedLayers()
-            for layerName in ['alayer', 'nlayer']:
+            for layerName in ['arc_layer', 'node_layer']:
                 try:                
                     inpLayer = int(self.inputData[layerName].GetValue())
                 except ValueError:
@@ -601,13 +601,13 @@ class VNETDialog(wx.Dialog):
 
     def UseTurns(self):
         if self.useTurns.IsChecked():
-            self.inputData["tlayer"].GetParent().Show()
-            self.inputData["tuclayer"].GetParent().Show()
+            self.inputData["turn_layer"].GetParent().Show()
+            self.inputData["turn_cat_layer"].GetParent().Show()
 
             self.vnet_mgr.SetParams(params = {}, flags = {"t" : True})
         else:
-            self.inputData["tlayer"].GetParent().Hide()
-            self.inputData["tuclayer"].GetParent().Hide()
+            self.inputData["turn_layer"].GetParent().Hide()
+            self.inputData["turn_cat_layer"].GetParent().Hide()
 
             self.vnet_mgr.SetParams(params = {}, flags = {"t" : False})
 
@@ -661,31 +661,31 @@ class VNETDialog(wx.Dialog):
         vectMapName, mapSet = self._parseMapStr(self.inputData['input'].GetValue())
         vectorMap = vectMapName + '@' + mapSet
 
-        for sel in ['alayer', 'nlayer']:#, 'tlayer', 'tuclayer']:
+        for sel in ['arc_layer', 'node_layer']:#, 'turn_layer', 'turn_cat_layer']:
             self.inputData[sel].Clear()
             self.inputData[sel].InsertLayers(vector = vectorMap)
 
-        items = self.inputData['alayer'].GetItems()
+        items = self.inputData['arc_layer'].GetItems()
         itemsLen = len(items)
         if itemsLen < 1:
             self.addToTreeBtn.Disable()
             if hasattr(self, 'inpDbMgrData'):
                 self._updateInputDbMgrPage(show = False)
-            self.inputData['alayer'].SetValue("")
-            self.inputData['nlayer'].SetValue("")
-            for sel in ['afcolumn', 'abcolumn', 'ncolumn']:
+            self.inputData['arc_layer'].SetValue("")
+            self.inputData['node_layer'].SetValue("")
+            for sel in ['arc_column', 'arc_backward_column', 'node_column']:
                 self.inputData[sel].SetValue("")
             return
         elif itemsLen == 1:
-            self.inputData['alayer'].SetSelection(0)
-            self.inputData['nlayer'].SetSelection(0)
+            self.inputData['arc_layer'].SetSelection(0)
+            self.inputData['node_layer'].SetSelection(0)
         elif itemsLen >= 1:
             if unicode("1") in items:
                 iItem = items.index(unicode("1")) 
-                self.inputData['alayer'].SetSelection(iItem)
+                self.inputData['arc_layer'].SetSelection(iItem)
             if unicode("2") in items:
                 iItem = items.index(unicode("2")) 
-                self.inputData['nlayer'].SetSelection(iItem)
+                self.inputData['node_layer'].SetSelection(iItem)
 
         self.addToTreeBtn.Enable()
         if hasattr(self, 'inpDbMgrData'):
@@ -699,17 +699,17 @@ class VNETDialog(wx.Dialog):
     def _updateParamsTab(self, params, flags):
         #TODO flag
 
-                #'tlayer', 'tuclayer', 
-        for k in ['input', 'alayer', 'nlayer', 'afcolumn', 'abcolumn', 'ncolumn']:
+                #'turn_layer', 'turn_cat_layer', 
+        for k in ['input', 'arc_layer', 'node_layer', 'arc_column', 'arc_backward_column', 'node_column']:
             self.inputData[k].SetValue(params[k])
 
     def OnALayerSel(self, event):
         """When arc layer from vector map is selected, populates corespondent columns selects"""
-        self.inputData['afcolumn'].InsertColumns(vector = self.inputData['input'].GetValue(), 
-                                                 layer = self.inputData['alayer'].GetValue(), 
+        self.inputData['arc_column'].InsertColumns(vector = self.inputData['input'].GetValue(), 
+                                                 layer = self.inputData['arc_layer'].GetValue(), 
                                                  type = self.columnTypes)
-        self.inputData['abcolumn'].InsertColumns(vector = self.inputData['input'].GetValue(), 
-                                                 layer = self.inputData['alayer'].GetValue(), 
+        self.inputData['arc_backward_column'].InsertColumns(vector = self.inputData['input'].GetValue(), 
+                                                 layer = self.inputData['arc_layer'].GetValue(), 
                                                  type = self.columnTypes)
 
         self._setInputData()
@@ -719,8 +719,8 @@ class VNETDialog(wx.Dialog):
         if self.vnet_mgr.IsSnappingActive():
             self.vnet_mgr.Snapping(activate = True)
 
-        self.inputData['ncolumn'].InsertColumns(vector = self.inputData['input'].GetValue(), 
-                                                layer = self.inputData['nlayer'].GetValue(), 
+        self.inputData['node_column'].InsertColumns(vector = self.inputData['input'].GetValue(), 
+                                                layer = self.inputData['node_layer'].GetValue(), 
                                                 type = self.columnTypes)
  
         self._setInputData()
@@ -794,16 +794,16 @@ class VNETDialog(wx.Dialog):
             GMessage(parent = self,
                      message = _("Input vector map does not exists."))
 
-        if ["tlayer", "tuclayer"] in err_params:
+        if ["turn_layer", "turn_cat_layer"] in err_params:
             GMessage(parent = self, message = "Please choose existing turntable layer and unique categories layer in Parameters tab.")
 
-        cat = GetNearestNodeCat(e, n, int(params['tuclayer']), snapTreshDist, params["input"])
+        cat = GetNearestNodeCat(e, n, int(params['turn_cat_layer']), snapTreshDist, params["input"])
 
         if not self.def_isec_turns:
             self.def_isec_turns = DefIntesectionTurnCostDialog(self, self.parent)
             self.def_isec_turns.SetSize((500, 400))
 
-        self.def_isec_turns.SetData(params["input"], params["tlayer"])
+        self.def_isec_turns.SetData(params["input"], params["turn_layer"])
         self.def_isec_turns.SetIntersection(cat)
         self.def_isec_turns.Show()
 
@@ -916,7 +916,7 @@ class VNETDialog(wx.Dialog):
                skip.append(colInptF)
             used_cols.append(colInptF)
 
-        for col in ["abcolumn", "afcolumn", "ncolumn"]:
+        for col in ["arc_backward_column", "arc_column", "node_column"]:
             if col not in used_cols:
                 inputPanel = self.inputData[colInptF].GetParent()
                 inputPanel.Hide()
@@ -1332,9 +1332,9 @@ class CreateTtbDialog(wx.Dialog):
         dataSelects = [
                         ['input', "Choose vector map for analysis:", Select],
                         ['output', "Name of vector map with turntable:", Select],
-                        ['alayer', "Arc layer which will be expanded by turntable:", LayerSelect],
-                        ['tlayer', "Layer with turntable:", LayerSelect],
-                        ['tuclayer', "Layer with unique categories for turntable:", LayerSelect],
+                        ['arc_layer', "Arc layer which will be expanded by turntable:", LayerSelect],
+                        ['turn_layer', "Layer with turntable:", LayerSelect],
+                        ['turn_cat_layer', "Layer with unique categories for turntable:", LayerSelect],
                       ]
 
         self.inputData = {}
@@ -1371,7 +1371,7 @@ class CreateTtbDialog(wx.Dialog):
                       flag = wx.EXPAND  | wx.TOP | wx.LEFT | wx.RIGHT, border = 5) 
 
         btn = None
-        for sel in ['input', 'output', 'alayer', 'tlayer', 'tuclayer']:                      
+        for sel in ['input', 'output', 'arc_layer', 'turn_layer', 'turn_cat_layer']:                      
 
             selPanels[sel].SetSizer(self._doSelLayout(title = label[sel], 
                                                       sel = self.inputData[sel], 
@@ -1431,24 +1431,24 @@ class CreateTtbDialog(wx.Dialog):
         vectMapName, mapSet = self._parseMapStr(self.inputData['input'].GetValue())
         vectorMap = vectMapName + '@' + mapSet
 
-        for sel in ['alayer', 'tlayer', 'tuclayer']:
+        for sel in ['arc_layer', 'turn_layer', 'turn_cat_layer']:
             self.inputData[sel].Clear()
             self.inputData[sel].InsertLayers(vector = vectorMap)
 
-        items = self.inputData['alayer'].GetItems()
+        items = self.inputData['arc_layer'].GetItems()
         itemsLen = len(items)
         if itemsLen < 1:
             self.addToTreeBtn.Disable()
             if hasattr(self, 'inpDbMgrData'):
                 self._updateInputDbMgrPage(show = False)
-            self.inputData['alayer'].SetValue("")
+            self.inputData['arc_layer'].SetValue("")
             return
         elif itemsLen == 1:
-            self.inputData['alayer'].SetSelection(0)
+            self.inputData['arc_layer'].SetSelection(0)
         elif itemsLen >= 1:
             if unicode("1") in items:
                 iItem = items.index(unicode("1")) 
-                self.inputData['alayer'].SetSelection(iItem)
+                self.inputData['arc_layer'].SetSelection(iItem)
         self.addToTreeBtn.Enable()
         if hasattr(self, 'inpDbMgrData'):
             self._updateInputDbMgrPage(show = True)

gui/wxpython/vnet/vnet_core.py

@@ -99,7 +99,7 @@ class VNETManager:
 
         params, err_params, flags = self.vnet_data.GetParams()
         relevant_params = self.vnet_data.GetRelevantParams(analysis)
-
+        
         if not relevant_params:
             return -1
 
@@ -272,9 +272,9 @@ class VNETManager:
                         "v.net.turntable",
                         "input=" + params["input"], 
                         "output=" + params["output"],
-                        "alayer=" + params["alayer"],
-                        "tlayer=" + params["tlayer"],
-                        "tuclayer=" + params["tuclayer"],
+                        "arc_layer=" + params["arc_layer"],
+                        "turn_layer=" + params["turn_layer"],
+                        "turn_cat_layer=" + params["turn_cat_layer"],
                         "--overwrite", 
                        ]
 
@@ -441,7 +441,7 @@ class VNETAnalyses:
                                         overwrite = True)
 
             self._updateTtbByGlobalCosts(self.tmpTurnAn.GetVectMapName(), 
-                                         int(params["tlayer"]))
+                                         int(params["turn_layer"]))
             
             #self._prepareCmd(cmdCopy)
             #self.goutput.RunCmd(command = cmdCopy)
@@ -492,7 +492,7 @@ class VNETAnalyses:
             for coor in pts_coor:
                 cat_num = str(GetNearestNodeCat(e = coor[0], 
                                                 n = coor[1], 
-                                                field = int(params["tuclayer"],
+                                                field = int(params["turn_cat_layer"],
                                                 tresh = params["max_dist"]), 
                                                 vectMap = params["input"]))
                 if cat_num < 0:
@@ -526,7 +526,7 @@ class VNETAnalyses:
                                     overwrite = True)
 
         self._updateTtbByGlobalCosts(self.tmpTurnAn.GetVectMapName(), 
-                                     int(params["tlayer"]))
+                                     int(params["turn_layer"]))
 
 
         self._setCmdForSpecificAn(cmdParams)
@@ -630,7 +630,7 @@ class VNETAnalyses:
                 maxCat = int(cat[4])
                 break
 
-        layerNum = params["nlayer"]
+        layerNum = params["node_layer"]
 
         pt_ascii, catsNums = self._getAsciiPts (catPts = catPts, 
                                                 maxCat = maxCat, 
@@ -678,8 +678,8 @@ class VNETAnalyses:
                     "points=" + self.tmpInPts.GetVectMapName(), 
                     "input=" + params['input'],
                     "output=" + self.tmpInPtsConnected.GetVectMapName(),
-                    "alayer=" +  params["alayer"],
-                    "nlayer=" +  params["nlayer"], 
+                    "arc_layer=" +  params["arc_layer"],
+                    "node_layer=" +  params["node_layer"], 
                     "operation=connect",
                     "thresh=" + str(params["max_dist"]),             
                     "--overwrite"                         
@@ -705,7 +705,7 @@ class VNETAnalyses:
     def _setInputParams(self, analysis, params, flags):
         """Return list of chosen values (vector map, layers). 
 
-        The list items are in form to be used in command for analysis e.g. 'alayer=1'.    
+        The list items are in form to be used in command for analysis e.g. 'arc_layer=1'.    
         """
 
         inParams = []
@@ -718,12 +718,12 @@ class VNETAnalyses:
 
             inParams.append(col + '=' + params[colInptF])
 
-        for layer in ['alayer', 'nlayer', 'tlayer', 'tuclayer']:
-            if not flags["t"] and layer in ['tlayer', 'tuclayer']:
+        for layer in ['arc_layer', 'node_layer', 'turn_layer', 'turn_cat_layer']:
+            if not flags["t"] and layer in ['turn_layer', 'turn_cat_layer']:
                 continue
             # TODO
-            if flags["t"] and layer == 'nlayer':
-                inParams.append(layer + "=" + params['tuclayer'])
+            if flags["t"] and layer == 'node_layer':
+                inParams.append(layer + "=" + params['turn_cat_layer'])
                 continue
 
             inParams.append(layer + "=" + params[layer])
@@ -1026,7 +1026,7 @@ class SnappingNodes(wx.EvtHandler):
                                      params = params,
                                      inv_params = inv_params,
                                      flags = flags,
-                                     relevant_params = ["input", "nlayer"]):
+                                     relevant_params = ["input", "node_layer"]):
             return -1
 
         if not self.tmp_maps.HasTmpVectMap("vnet_snap_points"):

gui/wxpython/vnet/vnet_data.py

@@ -13,7 +13,7 @@ Classes:
  - vnet_data::History
  - vnet_data::VNETGlobalTurnsData
 
-(C) 2013 by the GRASS Development Team
+(C) 2013-2014 by the GRASS Development Team
 
 This program is free software under the GNU General Public License
 (>=v2). Read the file COPYING that comes with GRASS for details.
@@ -141,7 +141,7 @@ class VNETData:
             :return: False if some of checked inputs is not ok
         """
 
-        if flags["t"] and  "tlayer" not in relevant_params:
+        if flags["t"] and  "turn_layer" not in relevant_params:
             GMessage(parent = self.guiparent, message = _("Module <%s> does not support turns costs." % analysis))
             return False
 
@@ -159,12 +159,12 @@ class VNETData:
             return False
 
         errLayerStr = ""
-        for layer, layerLabel in {'alayer' : _("arc layer"), 
-                                  'nlayer' : _("node layer"),
-                                  'tlayer' : _("turntable layer"),
-                                  'tuclayer' : _("unique categories layer")}.iteritems():
+        for layer, layerLabel in {'arc_layer' : _("arc layer"), 
+                                  'node_layer' : _("node layer"),
+                                  'turn_layer' : _("turntable layer"),
+                                  'turn_cat_layer' : _("unique categories layer")}.iteritems():
 
-            if layer in ["tlayer", "tuclayer"] and not flags["t"]:
+            if layer in ["turn_layer", "turn_cat_layer"] and not flags["t"]:
                 continue
             if layer in inv_params:
                 if params[layer]:
@@ -179,8 +179,8 @@ class VNETData:
             return False
 
         errColStr = ""
-        for col in ["afcol", "abcol", "ncol"]:
-            if col and col in inv_params and col in relevant_params:
+        for col in ["arc_column", "arc_backward_column", "node_column"]:
+            if params[col] and col in inv_params and col in relevant_params:
                 errColStr += _("Chosen column '%s' does not exist in attribute table of layer '%s' of vector map '%s'.\n") % \
                              (params[col], params[layer], params['input'])
 
@@ -543,13 +543,13 @@ class VNETAnalysisParameters:
 
         self.params = {"analysis"   : self.an_props.used_an[0],
                        "input"      : "",
-                       "alayer"     : "",
-                       "nlayer"     : "",
-                       "afcolumn"   : "",
-                       "abcolumn"   : "",
-                       "ncolumn"    : "",
-                       "tlayer"     : "",
-                       "tuclayer"   : "",
+                       "arc_layer"     : "",
+                       "node_layer"     : "",
+                       "arc_column"   : "",
+                       "arc_backward_column"   : "",
+                       "node_column"    : "",
+                       "turn_layer"     : "",
+                       "turn_cat_layer"   : "",
                        "iso_lines"  : "", #TODO check validity
                        "max_dist"   : 0} #TODO check validity
 
@@ -589,8 +589,8 @@ class VNETAnalysisParameters:
     def GetParam(self, param):
 
         invParams = []
-        if param in ["input", "alayer", "nlayer", "afcolumn", 
-                     "abcolumn", "ncolumn", "tlayer", "tuclayer"]:
+        if param in ["input", "arc_layer", "node_layer", "arc_column", 
+                     "arc_backward_column", "node_column", "turn_layer", "turn_cat_layer"]:
             invParams = self._getInvalidParams(self.params)
 
         if invParams: 
@@ -621,23 +621,23 @@ class VNETAnalysisParameters:
         # check arc/node layer
         layers = utils.GetVectorNumberOfLayers(params["input"])    
         
-        for l in ['alayer', 'nlayer', 'tlayer', 'tuclayer']:
+        for l in ['arc_layer', 'node_layer', 'turn_layer', 'turn_cat_layer']:
             if not layers or params[l] not in layers:
                 invParams.append(l)
 
         dbInfo = VectorDBInfo(params["input"])
 
         try:
-            table = dbInfo.GetTable(int(params["alayer"]))
+            table = dbInfo.GetTable(int(params["arc_layer"]))
             columnchoices = dbInfo.GetTableDesc(table)
         except (KeyError, ValueError):
             table = None
-
+        
         # check costs columns
-        for col in ["afcolumn", "abcolumn", "ncolumn"]:
-            if col == "ncolumn":
+        for col in ["arc_column", "arc_backward_column", "node_column"]:
+            if col == "node_column":
                 try:
-                    table = dbInfo.GetTable(int(params["nlayer"]))
+                    table = dbInfo.GetTable(int(params["node_layer"]))
                     columnchoices = dbInfo.GetTableDesc(table)
                 except (KeyError, ValueError):
                     table = None
@@ -645,7 +645,7 @@ class VNETAnalysisParameters:
             if not table or  not params[col]  in columnchoices.keys():
                 invParams.append(col)
                 continue
-
+            
             if not columnchoices[col].value['type'] not in ['integer', 'double precision']:
                 invParams.append(col)
                 continue
@@ -658,20 +658,20 @@ class VNETAnalysesProperties:
         # initialization of v.net.* analysis parameters (data which characterizes particular analysis)
 
         self.attrCols = {
-                          'afcolumn' : {
+                          'arc_column' : {
                                         "label" : _("Arc forward/both direction(s) cost column:"),
                                         "name" : _("arc forward/both")
                                        },
-                          'abcolumn' : {
+                          'arc_backward_column' : {
                                         "label" : _("Arc backward direction cost column:"),
                                         "name" : _("arc backward")
                                        },
                           'acolumn' : {
                                        "label" : _("Arcs' cost column (for both directions):"),
                                        "name" : _("arc"),
-                                       "inputField" : 'afcolumn',
+                                       "inputField" : 'arc_column',
                                       },
-                          'ncolumn' : {
+                          'node_column' : {
                                        "label" : _("Node cost column:"),
                                         "name" : _("node")                                      
                                       }
@@ -686,9 +686,9 @@ class VNETAnalysesProperties:
                                                                                     ["end_pt", _("End point")] 
                                                                                 ],
                                                                       "cols" :  [
-                                                                                 'afcolumn',
-                                                                                 'abcolumn',
-                                                                                 'ncolumn'
+                                                                                 'arc_column',
+                                                                                 'arc_backward_column',
+                                                                                 'node_column'
                                                                                 ],
                                                                    },
                                                      "resultProps" : {
@@ -701,10 +701,10 @@ class VNETAnalysesProperties:
                                     "v.net.salesman" : {
                                                         "label" : _("Traveling salesman %s") % "(v.net.salesman)",  
                                                         "cmdParams" : {
-                                                                        "cats" : [["ccats", None]],
+                                                                        "cats" : [["center_cats", None]],
                                                                         "cols" : [
-                                                                                  'afcolumn',
-                                                                                  'abcolumn'
+                                                                                  'arc_column',
+                                                                                  'arc_backward_column'
                                                                                  ],
                                                                       },
                                                         "resultProps" : {
@@ -722,9 +722,9 @@ class VNETAnalysesProperties:
                                                                                 ["sink_cats", _("Sink point")]
                                                                                ],                                                   
                                                                       "cols" : [
-                                                                                'afcolumn',
-                                                                                'abcolumn',
-                                                                                'ncolumn'
+                                                                                'arc_column',
+                                                                                'arc_backward_column',
+                                                                                'node_column'
                                                                                ]
                                                                   },
                                                      "resultProps" : {
@@ -736,11 +736,11 @@ class VNETAnalysesProperties:
                                     "v.net.alloc" : {
                                                      "label" : _("Subnets for nearest centers %s") % "(v.net.alloc)",  
                                                      "cmdParams" : {
-                                                                      "cats" : [["ccats", None]],                           
+                                                                      "cats" : [["center_cats", None]],                           
                                                                       "cols" : [
-                                                                                 'afcolumn',
-                                                                                 'abcolumn',
-                                                                                 'ncolumn'
+                                                                                 'arc_column',
+                                                                                 'arc_backward_column',
+                                                                                 'node_column'
                                                                                ]
                                                                   },
                                                      "resultProps" :  {
@@ -752,7 +752,7 @@ class VNETAnalysesProperties:
                                     "v.net.steiner" : {
                                                      "label" : _("Steiner tree for the network and given terminals %s") % "(v.net.steiner)",  
                                                      "cmdParams" : {
-                                                                      "cats" : [["tcats", None]],                           
+                                                                      "cats" : [["terminal_cats", None]],                           
                                                                       "cols" : [
                                                                                  'acolumn',
                                                                                ]
@@ -771,9 +771,9 @@ class VNETAnalysesProperties:
                                                                                   ["to_cats", "To point"]
                                                                                  ],
                                                                         "cols" : [
-                                                                                  'afcolumn',
-                                                                                  'abcolumn',
-                                                                                  'ncolumn'
+                                                                                  'arc_column',
+                                                                                  'arc_backward_column',
+                                                                                  'node_column'
                                                                                  ],
                                                                   },
                                                       "resultProps" : {
@@ -785,11 +785,11 @@ class VNETAnalysesProperties:
                                     "v.net.iso" :  {
                                                      "label" : _("Cost isolines %s") % "(v.net.iso)",  
                                                      "cmdParams" : {
-                                                                      "cats" : [["ccats", None]],                           
+                                                                      "cats" : [["center_cats", None]],                           
                                                                       "cols" : [
-                                                                                 'afcolumn',
-                                                                                 'abcolumn',
-                                                                                 'ncolumn'
+                                                                                 'arc_column',
+                                                                                 'arc_backward_column',
+                                                                                 'node_column'
                                                                                ]
                                                                   },
                                                      "resultProps" : {
@@ -830,10 +830,10 @@ class VNETAnalysesProperties:
         if not self.vnetProperties.has_key(analysis):
             return None
 
-        relevant_params = ["input", "alayer", "nlayer"]
+        relevant_params = ["input", "arc_layer", "node_layer"]
 
         if self.vnetProperties[analysis]["turns_support"]:
-            relevant_params += ["tlayer", "tuclayer"]
+            relevant_params += ["turn_layer", "turn_cat_layer"]
 
         cols = self.vnetProperties[analysis]["cmdParams"]["cols"]