Changes between Initial Version and Version 1 of El:Help/Plugin/Scripting/Python

Timestamp:

2025-06-09T15:35:23+02:00 (2 months ago)

Author:

makmar

Comment:

--

El:Help/Plugin/Scripting/Python

@@ +1 @@
+[[TranslatedPages(revision=18)]]
+
+= Πρόσθετο -> Δημιουργία Σεναρίων -> Python =
+== Σκοπός ==
+Μερικά ακόμη παραδείγματα στην Python:
+
+[[PageOutline(2,Table of Contents)]]
+
+
+== Μετατροπή γραμμής που συνδέεται με μη διαχωρισμένο κυκλικό κόμβο σε διακλάδωση ==
+Μετατροπή γραμμής που συνδέεται με κυκλικό κόμβο σε διακλάδωση αποτελούμενη από 2 γραμμές μονής κατεύθυνσης. Η γραμμή διαχωρίζεται στον τελευταίο της κόμβο και συνδέεται στους δύο κόμβους που βρίσκονται δίπλα στον κοινό κόμβο της γραμμής του κυκλικού κόμβου.
+Αυτή η έκδοση λειτουργεί μόνο σε μη διαχωρισμένους κυκλικούς κόμβους.
+Δείτε το επόμενο παράδειγμα για μια ενημερωμένη εκδοχή.
+
+{{{#!python
+from javax.swing import JOptionPane
+from org.openstreetmap.josm.gui import MainApplication
+
+import org.openstreetmap.josm.command as Command
+import org.openstreetmap.josm.data.osm.Way as Way
+
+editLayer = MainApplication.getLayerManager().getEditLayer()
+if editLayer and editLayer.data:
+    selected_ways = editLayer.data.getSelectedWays()
+    print selected_ways
+
+    if not(selected_ways) or len(selected_ways)>1:
+        JOptionPane.showMessageDialog(MainApplication.getMainFrame(),
+                                         "Please select a single way that connects to a roundabout")
+    else:
+        for way in selected_ways:
+            if way.get('oneway') in ['yes', '-1']:
+                JOptionPane.showMessageDialog(MainApplication.getMainFrame(), "This way has oneway tag set")
+            else:
+                node_before = None
+                node_after = None
+                common_node = None
+                common_node_becomes_node_before=None
+                #print dir(way)
+                for fln in [way.firstNode(),  way.lastNode()]:
+                    print 'fln',  fln
+                    for parentway in fln.getParentWays():
+                        if parentway.get("junction")=='roundabout':
+                            for n in parentway.getNodes():
+                                if common_node:
+                                    # found common node between selected way and
+                                    # roundabout way in previous iteration
+                                    node_after = n
+                                    # we are done here
+                                    break
+                                if n.getId() == fln.getId():
+                                    # this is the node the roundabout has in common with selected way
+                                    common_node = n
+                                    if not(node_before):
+                                        # normally we encountered a node on the roundabout way
+                                        # before this one, but if the common node is the first node
+                                        # of an unsplit roundabout, we will need to take the last
+                                        # node of the roundabout instead
+                                        node_before = parentway.getNodes()[-2]
+                                        node_after = parentway.getNodes()[1]
+                                        break
+                                    # if not we go through the loop one more time to put the next
+                                    # node in node_after
+                                    continue
+                                node_before = n
+                        if common_node:
+                            # if common_node is already defined at this point, it means it was
+                            # the first node of the selected way,
+                            # so it will have to be replaced with node_before in the selected way
+                            common_node_becomes_node_before = True
+                            adjacent_node_to_split_on = way.getNodes()[1]
+                            break
+                        else:
+                            common_node_becomes_node_before = False
+                            adjacent_node_to_split_on = way.getNodes()[-1]
+                if not(common_node) or common_node_becomes_node_before==None:
+                    JOptionPane.showMessageDialog(MainApplication.getMainFrame(),
+                                               "Please select a way that connects to a roundabout")
+                else:
+                    print common_node.get('name')
+                    print node_before.get('name')
+                    print node_after.get('name')
+
+                    commandsList = []
+                    if len(way.getNodes())>2:
+                        # split off last segment before roundabout if needed
+                        commandsList.append(Command.SplitWayCommand.split(
+                                    way, [adjacent_node_to_split_on], []))
+                        MainApplication.undoRedo.add(Command.SequenceCommand(
+                                    "Split selected way", commandsList))
+                        commandsList = []
+                    # After splitting find the segment that connects to the roundabout again
+                    for waypartconnectedtoroundabout in adjacent_node_to_split_on.getParentWays():
+                        if common_node in waypartconnectedtoroundabout.getNodes():
+                            break
+                    if len(way.getNodes())==2:
+                        if common_node == waypartconnectedtoroundabout.firstNode():
+                            adjacent_node_to_split_on = waypartconnectedtoroundabout.lastNode()
+                        else:
+                            adjacent_node_to_split_on = waypartconnectedtoroundabout.firstNode()
+                    # time to actually do something
+                    # make a copy of the way
+                    modified_way = Way(waypartconnectedtoroundabout)
+                    # replace its nodes, so it becomes a fork
+                    modified_way.setNodes([node_before, adjacent_node_to_split_on, node_after])
+                    # add oneway tag
+                    modified_way.put('oneway', 'yes')
+                    # apply the changes
+                    commandsList.append(Command.ChangeCommand(
+                                    waypartconnectedtoroundabout, modified_way))
+                    MainApplication.undoRedo.add(Command.SequenceCommand(
+                                    "Add oneway tag and create forked way", commandsList))
+                    commandsList = []
+                    # split this way where it forks
+                    commandsList.append(Command.SplitWayCommand.split(
+                                    waypartconnectedtoroundabout, [adjacent_node_to_split_on], []))
+                    MainApplication.undoRedo.add(Command.SequenceCommand(
+                                    "Split fork into 2 ways", commandsList))
+                    commandsList = []
+
+}}}
+
+
+== Μετατροπή γραμμής που συνδέεται με διαχωρισμένο κυκλικό κόμβο σε διακλάδωση ==
+Αυτό το σενάριο κάνει το ίδιο με το προηγούμενο, αλλά λειτουργεί και σε κυκλικούς κόμβους όπου οι γραμμές είναι διαχωρισμένες. Δεν λαμβάνει υπόψη του τις σχέσεις.
+
+{{{#!python
+from javax.swing import JOptionPane
+from org.openstreetmap.josm.gui import MainApplication
+
+import org.openstreetmap.josm.command as Command
+import org.openstreetmap.josm.data.osm.Way as Way
+
+editLayer = MainApplication.getLayerManager().getEditLayer()
+print '==== Fresh run ===='
+if editLayer and editLayer.data:
+    selected_ways = editLayer.data.getSelectedWays()
+    print selected_ways
+
+    if not(selected_ways) or len(selected_ways)>1:
+        JOptionPane.showMessageDialog(MainApplication.getMainFrame(), "Please select a single way that connects to a roundabout")
+    else:
+        for way in selected_ways:
+            if way.get('oneway') in ['yes', '-1']:
+                JOptionPane.showMessageDialog(MainApplication.getMainFrame(), "This way has oneway tag set")
+            elif way.get('junction') in ['roundabout']:
+                JOptionPane.showMessageDialog(MainApplication.getMainFrame(), "This way is part of a roundabout")
+            else:
+                node_before = None
+                node_after = None
+                common_node = None
+                common_node_becomes_node_before=None
+                roundabout_way_before = None
+                roundabout_way_after = None
+                for fln in [way.firstNode(),  way.lastNode()]:
+                    print 'fln',  fln
+                    for parentway in fln.getParentWays():
+                        if parentway.get("junction")=='roundabout':
+                            print parentway.get('name')
+                            if parentway.isClosed():
+                                # unsplit roundabout
+                                for n in parentway.getNodes():
+                                    if common_node:
+                                        # found common node between selected way
+                                        # and roundabout way in previous iteration
+                                        node_after = n
+                                        print node_before.get('name')
+                                        print node_after.get('name')
+                                        # we are done here
+                                        break
+                                    if n.getId() == fln.getId():
+                                        # this is the node the roundabout has in common with selected way
+                                        common_node = n
+                                        print common_node.get('name')
+                                        if not(node_before):
+                                            # normally we encountered a node on the roundabout way
+                                            # before this one, but if the common node is the first node
+                                            # of an unsplit roundabout, we will need to take the last
+                                            # node of the roundabout instead
+                                            node_before = parentway.getNodes()[-2]
+                                            node_after = parentway.getNodes()[1]
+                                            print node_before.get('name')
+                                            print node_after.get('name')
+                                            break
+                                        # if not we go through the loop one more time to put the next
+                                        # node in node_after
+                                        continue
+                                    node_before = n
+                            else:
+                                # this is a split roundabout
+                                if parentway.firstNode().getId() == fln.getId():
+                                    node_after = parentway.getNodes()[1]
+                                    roundabout_way_after = parentway
+                                    print 'node after', node_after.get('name')
+                                else:
+                                    node_before = parentway.getNodes()[-2]
+                                    roundabout_way_before = parentway
+                                if node_before and node_after:
+                                    common_node = fln
+                                    break
+
+                            if common_node:
+                                # if common_node is already defined at this point, it means it was
+                                # the first node of the selected way,
+                                # so it will have to be replaced with node_before in the selected way
+                                common_node_becomes_node_before = True
+                                break
+                            else:
+                                common_node_becomes_node_before = False
+                        
+                if common_node.getId() == way.firstNode().getId():
+                    adjacent_node_to_split_on = way.getNodes()[1]
+                else:
+                    adjacent_node_to_split_on = way.getNodes()[-1]
+
+                if not(common_node) or ((parentway.isClosed() and common_node_becomes_node_before==None)):
+                    JOptionPane.showMessageDialog(MainApplication.getMainFrame(), "Please select a way that connects to a roundabout")
+                else:
+                    commandsList = []
+                    if len(way.getNodes())>2:
+                        # split off last segment before roundabout if needed
+                        commandsList.append(Command.SplitWayCommand.split(
+                                    way, [adjacent_node_to_split_on], []))
+                        MainApplication.undoRedo.add(Command.SequenceCommand(
+                                    "Split selected way", commandsList))
+                        commandsList = []
+                    # After splitting find the segment that connects to the roundabout again
+                    for waypartconnectedtoroundabout in adjacent_node_to_split_on.getParentWays():
+                        if waypartconnectedtoroundabout.get('junction') == 'roundabout':
+                            continue
+                        if common_node in waypartconnectedtoroundabout.getNodes():
+                            break
+                    if len(way.getNodes())==2:
+                        if common_node == waypartconnectedtoroundabout.firstNode():
+                            adjacent_node_to_split_on = waypartconnectedtoroundabout.lastNode()
+                        else:
+                            adjacent_node_to_split_on = waypartconnectedtoroundabout.firstNode()
+                    # time to actually do something
+                    # make a copy of the way
+                    modified_way = Way(waypartconnectedtoroundabout)
+                    # replace its nodes, so it becomes a fork
+                    modified_way.setNodes([node_before, adjacent_node_to_split_on, node_after])
+                    # add oneway tag
+                    modified_way.put('oneway', 'yes')
+                    # apply the changes
+                    commandsList.append(Command.ChangeCommand(
+                                    waypartconnectedtoroundabout, modified_way))
+                    MainApplication.undoRedo.add(Command.SequenceCommand(
+                                    "Add oneway tag and create forked way", commandsList))
+                    commandsList = []
+                    # split this way where it forks
+                    commandsList.append(Command.SplitWayCommand.split(
+                                    waypartconnectedtoroundabout, [adjacent_node_to_split_on], []))
+                    MainApplication.undoRedo.add(Command.SequenceCommand(
+                                    "Split fork into 2 ways", commandsList))
+                    commandsList = []
+                    
+                    if roundabout_way_before and roundabout_way_after:
+                        origway = roundabout_way_before
+                        roundabout_way_before.addNode(node_after)
+                        commandsList.append(Command.ChangeCommand(
+                                        origway,  roundabout_way_before))
+                        origway = roundabout_way_after
+                        roundabout_way_after.removeNode(common_node)
+                        commandsList.append(Command.ChangeCommand(
+                                        origway,roundabout_way_after))
+#                        middleway = Way(roundabout_way_after).setNodes(
+#                                        [node_before, common_node, node_after])
+#                        commandsList.append(Command.AddCommand(editLayer.data, middleway))
+#                        MainApplication.undoRedo.add(Command.SequenceCommand(
+#                                        "Add way on roundabout where fork attaches", commandsList))
+                        commandsList.append(Command.SplitWayCommand.split(
+                                        roundabout_way_before, [node_before], []))
+                        MainApplication.undoRedo.add(Command.SequenceCommand(
+                                        "Split roundabout way", commandsList))
+                        commandsList = []
+
+}}}
+
+
+== Εξαγωγή συλλογής διαδρομών σε αρχείο Garmin GPX ==
+Εξαγωγή συλλογής διαδρομών σε αρχείο Garmin GPX (όχι το καλύτερο παράδειγμα, καθώς δεν χρησιμοποιούμε πλέον σχέσεις τύπου συλλογής):
+
+{{{#!python
+#!/bin/jython
+'''
+RWN2Garmin.py  - Numbered networks to Garmin GPX file converter
+This code is released under the GNU General Public License v2 or later.
+
+The GPL v3 is accessible here:
+https://www.gnu.org/licenses/gpl.html
+
+It comes with no warranty whatsoever.
+'''
+from javax.swing import JOptionPane, JDialog
+from java.awt.event import ActionListener, ActionEvent
+from org.openstreetmap.josm import Main
+import org.openstreetmap.josm.command as Command
+import org.openstreetmap.josm.data.osm.Node as Node
+import org.openstreetmap.josm.data.osm.Way as Way
+import org.openstreetmap.josm.data.osm.TagCollection as TagCollection
+import org.openstreetmap.josm.data.osm.DataSet as DataSet
+import time
+
+f = open('C:/export.gpx', 'w')
+f.write('<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n')
+f.write('<gpx xmlns="https://www.topografix.com/GPX/1/1" creator="OSM Route Manager" version="1.1" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="https://www.topografix.com/GPX/1/1 https://www.topografix.com/GPX/1/1/gpx.xsd">\n')
+f.write('<!-- All data by OpenStreetMap, licensed under cc-by-sa-2.0 (https://creativecommons.org/licenses/by-sa/2.0/). -->\n')
+
+editLayer = Main.getLayerManager().getEditLayer()
+if editLayer and editLayer.data:
+    selectedRelations = mv.editLayer.data.getSelectedRelations()
+
+    if not(selectedRelations):
+        JOptionPane.showMessageDialog(Main.parent, "Please select a collection relation")
+    else:
+        print
+        for collection in selectedRelations:
+            print 'COLLECTION:', collection
+            for member in collection.getMembers():
+                print 'MEMBER:',member
+                if member.isNode():
+                    node = member.getNode()
+                    coords = node.getCoor()
+                    lon = coords.getX()
+                    lat = coords.getY()
+                    rwn_ref = node.get('rwn_ref')
+                    f.write('\t<wpt lat="' + str(lat) + '" lon="' + str(lon) + '">\n')
+                    if rwn_ref:
+                        f.write('\t\t<name>' + rwn_ref + '</name>\n')
+                    f.write('\t</wpt>\n')
+            for member in collection.getMembers():
+                if member.isRelation():
+                    routerelation = member.getRelation()
+                    f.write('\t<trk>\n')
+                    networkname =  routerelation.get('network:name')
+                    if not(networkname):
+                        networkname =  ''
+                    else:
+                        networkname += ' '
+                    note = routerelation.get('note')
+                    if not(note): note =  ''
+                    f.write('\t\t<name>' + networkname + note + '</name>\n')
+                    f.write('\t\t<src>OpenStreetMap.org</src>\n')
+                    f.write('\t\t<type>foot</type>\n')
+                    for routerelmember in routerelation.getMembers():
+                        if routerelmember.isWay():
+                            f.write('\t\t<trkseg>\n')
+                            way=routerelmember.getWay()
+                            for waynode in way.getNodes():
+                                 coords = waynode.getCoor()
+                                 lon = coords.getX()
+                                 lat = coords.getY()
+                                 f.write('\t\t\t<trkpt lat="' + str(lat) + '" lon="' + str(lon) + '"> </trkpt>\n')
+
+                            f.write('\t\t</trkseg>\n')
+                    f.write('\t</trk>\n')
+f.write('</gpx>\n')
+f.close()
+}}}
+
+
+== Λήψη των ελλειπόντων γονικών στοιχείων για το επιλεγμένο στοιχείο ==
+
+{{{#!python
+#!/bin/jython
+'''
+
+This code is released under the GNU General
+Public License v2 or later.
+
+The GPL v3 is accessible here:
+https://www.gnu.org/licenses/gpl.html
+
+The GPL v2 is accessible here:
+https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+
+It comes with no warranty whatsoever.
+
+This code illustrates how to use Jython to:
+* Download all referrers for an element
+
+'''
+from javax.swing import JOptionPane
+from org.openstreetmap.josm import Main
+import org.openstreetmap.josm.actions.DownloadReferrersAction as DownloadReferrersAction
+
+editLayer = Main.getLayerManager().getEditLayer()
+if editLayer and editLayer.data:
+    selectedElements = editLayer.data.getSelected()
+    
+    if not(selectedElements):
+        JOptionPane.showMessageDialog(Main.parent, "Please select an element")
+    else:
+        DownloadReferrersAction.downloadReferrers(editLayer, selectedElements)
+}}}
+
+
+== Λήψη των ελλειπόντων μελών της σχέσης ==
+
+{{{
+#!/bin/jython
+'''
+
+This code is released under the GNU General
+Public License v2 or later.
+
+The GPL v3 is accessible here:
+https://www.gnu.org/licenses/gpl.html
+
+The GPL v2 is accessible here:
+https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+
+It comes with no warranty whatsoever.
+
+This code illustrates how to use Jython to:
+* Download all missing members of a relation
+
+'''
+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
+
+editLayer = Main.getLayerManager().getEditLayer()
+if editLayer:
+    selectedRelations = editLayer.data.getSelectedRelations()
+    
+    if not(selectedRelations):
+        JOptionPane.showMessageDialog(Main.parent, "Please select a relation")
+    else:
+        for relation in selectedRelations:
+            if relation.hasIncompleteMembers():
+                #print dir(relation)
+                print dir(DownloadRelationMemberTask)
+                DownloadRelationMemberTask.run(DownloadRelationMemberTask(relation, relation.getIncompleteMembers(), editLayer ))
+}}}
+
+
+== Επαλήθευση σχέσης διαδρομής rcn ==
+
+{{{
+#!/bin/jython
+'''
+- Validation of a rcn route relation
+
+This code is released under the GNU General
+Public License v2 or later.
+
+The GPL v3 is accessible here:
+https://www.gnu.org/licenses/gpl.html
+
+The GPL v2 is accessible here:
+https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+
+It comes with no warranty whatsoever.
+
+This code illustrates how to use Jython to:
+* loop over all members of a route relation
+* find out whether the member is a node, a way or a relation
+* add/change properties of a relation
+* remove properties of a relation
+* add members to a relation
+* remove members from a relation
+* sort all members backwards
+
+* How to set an element selected
+
+'''
+from javax.swing import JOptionPane
+from org.openstreetmap.josm import Main
+import org.openstreetmap.josm.command as Command
+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 re
+
+commandsList = []
+reNumberDashNumber = re.compile(r'\d+-\d+')
+def getMapView():
+    if Main.main and Main.main.map:
+        return Main.main.map.mapView
+    else:
+        return None
+
+mv = getMapView()
+if mv and mv.editLayer and mv.editLayer.data:
+    dummy_relation = Relation()
+    selectedRelations = mv.editLayer.data.getSelectedRelations()
+
+    if not(selectedRelations):
+        JOptionPane.showMessageDialog(Main.parent, "Please select a route relation")
+    else:
+        print
+        for route in selectedRelations:
+            newRelation = Relation(route)
+            relationChanged = False
+            name = route.get('name')
+            if name:
+                if reNumberDashNumber.match(name):
+                    print 'removing name when it is of the form ##-##'
+                    newRelation.remove('name')
+                    relationChanged = True
+            else:
+                name = ''
+            ref = route.get('ref')
+            if ref:
+                if reNumberDashNumber.match(ref):
+                    print 'removing ref when it is of the form ##-##'
+                    newRelation.remove('ref')
+                    relationChanged = True
+            else:
+                ref = ''
+            if relationChanged:
+                commandsList.append(Command.ChangeCommand(route, newRelation))
+                
+                Main.main.undoRedo.add(Command.SequenceCommand("Removing name and/or ref " + name + '/' + ref, commandsList))
+                commandsList = []
+
+            rcn_refs = []; route_relation_names = []; memberslist = []
+            endnodes = []; prev_endnodes = []
+            continuous_forward = True; continuous_backward = True
+            prev_role = None; prev_endnodes_before_forward = None; last_endnodes_before_backward = None
+            for member in route.getMembers():
+                if member.isWay():
+                    role = member.getRole()
+                    memberslist.append(member)
+                    way = member.getWay()
+                    #JOptionPane.showMessageDialog(Main.parent, 'way is selected')
+                    endnodes = [way.getNode(0), way.getNode(way.nodesCount-1)]
+                    notfoundyet = True
+                    for endnode in endnodes:
+                        # inventorizing of rcn_ref on end nodes
+                        rcn_ref = endnode.get('rcn_ref')
+                        if rcn_ref:
+                            rcn_refs.append(int(rcn_ref))
+                            for referrer in endnode.getReferrers():
+                                if referrer.getType() is dummy_relation.getType():
+                                    if referrer.get('type')=='network' and referrer.get('network')=='rcn':
+                                        relname=referrer.get('name')
+                                        if relname:
+                                            route_relation_names.append(relname)
+                                        
+                                    elif referrer.get('type')=='collection':
+                                        route_relation_names.append('Node not assigned to network yet')
+                        # checking for continuity on ways
+                        if notfoundyet:
+                            if role:
+                                if prev_role:
+                                    if role=='forward' and prev_role=='forward' and endnode in prev_endnodes:
+                                        notfoundyet = False
+                                    elif role=='forward' and prev_role=='backward' and endnode in last_endnodes_before_backward:
+                                        notfoundyet = False
+                                    elif role=='backward' and prev_role=='forward' and endnode in prev_endnodes:
+                                        notfoundyet = False
+                                    elif role=='backward' and prev_role=='backward' and endnode in prev_endnodes:
+                                        notfoundyet = False
+                                else:
+                                    if role=='forward' and endnode in prev_endnodes:
+                                        notfoundyet = False
+                                    elif role=='backward' and endnode in prev_endnodes:
+                                        notfoundyet = False
+                            else:
+                                if prev_role:
+                                    if prev_role=='forward' and endnode in prev_endnodes:
+                                        notfoundyet = False
+                                    elif prev_role=='backward' and endnode in last_endnodes_before_backward:
+                                        notfoundyet = False
+                                else:
+                                    if endnode in prev_endnodes:
+                                        notfoundyet = False
+                    # Analysis of continuity of ways
+                    if prev_endnodes and notfoundyet:
+                        if role:
+                            if role == 'forward':
+                                continuous_forward = False
+                            elif role == 'backward':
+                                continuous_backward = False
+                        else:
+                            continuous_forward = False
+                            continuous_backward = False
+                    if role=='forward':
+                        if not(prev_endnodes_before_forward):
+                            prev_endnodes_before_forward  = prev_endnodes
+                    elif prev_role=='forward' and role=='backward':
+                        if not(last_endnodes_before_backward):
+                            last_endnodes_before_backward = prev_endnodes
+                    elif not(role) and prev_role=='backward':
+                        prev_endnodes_before_forward = None
+                    prev_role = role
+                    prev_endnodes = endnodes
+            # Drawing conclusions about continuity of ways
+            if continuous_forward:
+                print 'route is continous in the forward direction'
+            else:
+                print 'route is NOT CONTINUOUS in the forward direction'
+            if continuous_backward:
+                print 'route is continous in the backward direction'
+            else:
+                print 'route is NOT CONTINUOUS in the backward direction'
+
+            # Drawing conclusions about rcn_refs
+            print rcn_refs
+            if len(rcn_refs) > 1:
+                newRelation = Relation(route)
+                relationChanged = False
+
+                if rcn_refs[0] > rcn_refs[1]:
+                    rcn_refs.sort()
+                    print 'Flipping members order'
+                    for member in reversed(memberslist):
+                        newRelation.addMember( newRelation.getMembersCount(), member)
+                        newRelation.removeMember (0)
+                    commandsList.append(Command.ChangeCommand(route, newRelation))
+                    Main.main.undoRedo.add(Command.SequenceCommand("Flipping order of members", commandsList))
+                    commandsList = []
+                note = route.get('note')
+                newNote = str(rcn_refs[0]).zfill(2) + '-' + str(rcn_refs[1]).zfill(2)
+                if not(note) or note != newNote:
+                    if not(note): note = 'nothing'
+                    newRelation.put('note', newNote)
+                    relationChanged = True
+                    commandsList.append(Command.ChangeCommand(route, newRelation))
+                
+                    Main.main.undoRedo.add(Command.SequenceCommand("Changing note from " + note + ' to ' + newNote, commandsList))
+                    commandsList = []
+
+                if len(route_relation_names) > 1 and route_relation_names[0] != route_relation_names[1]:
+                    print
+                    print 'This is probably a CONNECTION to another network'
+                    print route_relation_names
+            else:
+                print 'less than 2 end nodes with rcn_ref found'
+}}}
+
+[wiki:/Help/Plugin/Scripting/Python/RCN_Route_Validator]
+
+
+== Αφαίρεση επιπλέον γραμμών που προέκυψαν από ενέργειες στο Potlatch ==
+Αφαίρεση επιπλέον γραμμών που προέκυψαν από διαχωρισμό γραμμών στο Potlatch σε σχέσεις περιορισμού στροφής
+
+{{{#!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:
+https://www.gnu.org/licenses/gpl.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 works 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 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 when 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')
+editLayer = Main.getLayerManager().getEditLayer()
+if editLayer and editLayer.data:
+    selectedRelations = 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)
+                    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=[]
+}}}
+
+
+----
+Πίσω στο [wikitr:/Help/Plugin/Scripting Πρόσθετο Δημιουργίας Σεναρίων] \\
+Πίσω στη [wikitr:/Plugins Βοήθεια Πρόσθετων] \\
+Πίσω στη [wikitr:/Help Βασική Βοήθεια]
+