Changes between Version 9 and Version 10 of Help/Plugin/Scripting/Python

Timestamp:

2012-06-20T18:01:33+02:00 (14 years ago)

Author:

hlaw

Comment:

New script

Help/Plugin/Scripting/Python

@@ -404 +404 @@
 
 [wiki:Python/RCN_Route_Validator]
+
+Remove extra ways resulting from Potlatch way split operations under turn restriction relations
+
+{{{#!python
+
+#!/bin/jython
+
+'''
+RepairTurns.py  - Remove extra ways resulting from Potlatch way split operations under turn restriction relations
+
+This code is released under the GNU General
+Public License v2 or later.
+
+The GPL v3 is accessible here:
+http://www.gnu.org/licenses/gpl.html
+
+The GPL v2 is accessible here:
+http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+
+It comes with no warranty whatsoever.
+
+This code Loops through selected turn restriction relations, trying to remove ways split from originally the same way (with to / from roles) under turn restriction relations which should no longer remain as members of these relations, as a result of a Potlatch issue: https://trac.openstreetmap.org/ticket/3254
+
+Only work for turn restrictions with one via node
+
+e.g. Original      : from: Way1, via: Node, to:Way2
+     Split         : from: Way1a, from: Way1b, via: Node, to: Way2
+     After running : from: Way1b, via: Node, to: Way2
+
+This code illustrates how to use Jython to:
+* process selected items
+* download missing primitives in the same thread (blocking)
+* process, validate and remove members from relations
+
+'''
+from javax.swing import JOptionPane
+from org.openstreetmap.josm import Main
+import org.openstreetmap.josm.data.osm.Node as Node
+import org.openstreetmap.josm.data.osm.Way as Way
+import org.openstreetmap.josm.data.osm.Relation as Relation
+import org.openstreetmap.josm.data.osm.TagCollection as TagCollection
+import org.openstreetmap.josm.data.osm.DataSet as DataSet
+import org.openstreetmap.josm.data.osm.RelationMember as RelationMember
+import org.openstreetmap.josm.gui.dialogs.relation.DownloadRelationMemberTask as DownloadRelationMemberTask
+import org.openstreetmap.josm.io.MultiFetchServerObjectReader as MultiFetchServerObjectReader
+import org.openstreetmap.josm.gui.progress.PleaseWaitProgressMonitor as PleaseWaitProgressMonitor
+import org.openstreetmap.josm.command as Command
+
+class RestrictionError(Exception):
+    pass
+
+def getMapView():
+    if Main.main and Main.main.map:
+        return Main.main.map.mapView
+    else:
+        return None
+
+def getMembers (restriction):
+    memberlist = dict()
+    for member in restriction.getMembers():
+        memberRole = member.getRole()
+        if memberRole == "via":
+            if member.isNode() and not "via" in memberlist:
+                memberlist[memberRole] = [member]
+            else:
+                raise RestrictionError, "More than one via role or via not a node"
+        elif memberRole in ("from", "to"):
+            if member.isWay():
+                try:
+                    memberlist[memberRole].append (member)
+                except KeyError:
+                    memberlist[memberRole] = [member]
+            else:
+                raise RestrictionError, "From or to role not a way"
+        else: 
+            raise RestrictionError, "Unknown role " + memberRole
+
+    if len(memberlist.keys())<3:
+        raise RestrictionError, "Some roles missing: Only " + ",".join (memberlist.keys()) + " found"
+    return memberlist
+
+def downloadPrimitives (primitives, editlayer):
+    """
+        Download a list of primitives from server, and merge into editlayer. Blocking.
+    """
+    monitor = PleaseWaitProgressMonitor()
+    monitor.showForegroundDialog()   
+
+    print "Downloading"
+    try:
+        objectReader = MultiFetchServerObjectReader().append (primitives)
+        dataSet = objectReader.parseOsm (monitor)
+        editlayer.mergeFrom (dataSet)
+        editlayer.onPostDownloadFromServer()
+        if (not objectReader.getMissingPrimitives().isEmpty()) :
+            raise RestrictionError, "Unable to download missing primitives"
+        print "Download completed"    
+    finally:
+        monitor.close()
+
+def checkIfConnected (node, way, reverse):
+    """
+        Return (connected, next node to compare (i.e. other end of the node) if true)
+    """
+    if (way.isOneway() != 0 and reverse):
+        return node == way.lastNode(True), way.firstNode(True) # True: auto process case whan isOneway == -1
+    if (way.isOneway() != 0):     # not reverse
+        return node == way.firstNode(True), way.lastNode(True)
+    if node == way.firstNode():
+        return True, way.lastNode()
+    if node == way.lastNode():
+        return True, way.firstNode()
+    return False, node   
+
+
+def repairrestriction (relation, memberlist, editLayer):
+    """
+        Download missing members if needed, get list of members to remove, and remove them if no error raised during checking
+    """
+    incompleteMembers = relation.getIncompleteMembers()
+    if incompleteMembers:
+          downloadPrimitives (incompleteMembers, editLayer);        
+
+    fromRemovalList = []; toRemovalList = []
+    
+    if len (memberlist["from"]) >= 1:
+        currnode = memberlist["via"][0].getNode()
+        firstMember = True
+        failed = False;
+        # trace "from" members to confirm if split from one way
+        for member in reversed(memberlist['from']):
+            connected, currnode = checkIfConnected (currnode, member.getWay(), True)
+            if not connected:
+                if not firstMember:
+                    raise RestrictionError, "from ways not continuous from via node" 
+                failed = True
+                break
+            if not firstMember:
+                fromRemovalList.append (member)
+            else:
+                firstMember = False
+
+        if failed: # Second attempt in case sequence reversed when split
+            currnode = memberlist["via"][0].getNode()
+            for member in memberlist['from']:
+                connected, currnode = checkIfConnected (currnode, member.getWay(), True)
+                if not connected:
+                    raise RestrictionError, "from ways not continuous from via node"
+                if not firstMember:
+                    fromRemovalList.append (member)
+                else:
+                    firstMember = False
+                                                                        
+    if len (memberlist["to"]) >= 1:
+        currnode = memberlist["via"][0].getNode()
+        firstMember = True
+        failed = False
+        # trace "to" members to confirm if split from one way
+        for member in memberlist['to']:
+            connected, currnode = checkIfConnected (currnode, member.getWay(), False)
+            if not connected:
+                if not firstMember:
+                    raise RestrictionError, "to ways not continuous from via node" 
+                failed = True
+                break
+            if not firstMember:
+                toRemovalList.append (member)
+            else:
+                firstMember = False
+
+        if failed: # Second attempt in case sequence reversed when split
+            currnode = memberlist["via"][0].getNode()
+            for member in reversed(memberlist['to']):
+                connected, currnode = checkIfConnected (currnode, member.getWay(), False)
+                if not connected:
+                    raise RestrictionError, "to ways not continuous from via node"
+                if not firstMember:
+                    toRemovalList.append (member)
+                else:
+                    firstMember = False          
+                         
+    # to remove ways in fromRemovalList, toRemovalList          
+    newRelation = Relation(relation)
+    waysToRemove = set()
+    for removalList in [fromRemovalList, toRemovalList]:
+        waysToRemove |= set ([m.getWay() for m in removalList])
+    newRelation.removeMembersFor (waysToRemove)
+    print "Remove way(s) id:" + ",".join ([str(w.getId()) for w in waysToRemove])
+    return Command.ChangeCommand (relation, newRelation)   
+    
+    
+validrestrictiontypes = ('only_straight_on', 'only_right_turn', 'only_left_turn', 'no_right_turn', 'no_left_turn', 'no_straight_on', 'no_u_turn')
+mv = getMapView()
+if mv and mv.editLayer and mv.editLayer.data:
+    selectedRelations = mv.editLayer.data.getSelectedRelations()
+   
+    if not(selectedRelations):
+        JOptionPane.showMessageDialog(Main.parent, "Please select one or more relations")
+    else:
+        commandsList = []
+        for relation in selectedRelations:
+            if relation.get('type') == "restriction" and relation.get('restriction') in validrestrictiontypes:
+                try:
+                    memberlist = getMembers (relation)      
+                    #print "".join(v * len(memberlist[v]) for v in memberlist.keys())           
+                    if (len (memberlist["from"])) > 1 or (len (memberlist["to"])) > 1 :
+                        # Repair attempt
+                        print "Attempt repair",
+                        print "relation id: " + str(relation.getId())
+                        command = repairrestriction (relation, memberlist, mv.editLayer)
+                        print "Success"                         
+                        commandsList.append (command)
+                except RestrictionError, e:
+                    print str(e), "; relation id: "+ str(relation.getId())
+                
+        
+        Main.main.undoRedo.add(Command.SequenceCommand("Repair turn restrictions", commandsList))
+        commandsList=[]
+}}}