Changeset 32597 in osm for applications/editors/josm/plugins/pt_assistant/src

Timestamp:

2016-07-07T01:32:55+02:00 (9 years ago)

Author:

darya

Message:

fix for oneway test, RE updates

Location:

applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant

Files:

• gui/PTAssistantLayer.java (modified) (1 diff)
• gui/PTAssistantPaintVisitor.java (modified) (2 diffs)
• utils/RouteUtils.java (modified) (2 diffs)
• validation/Checker.java (modified) (1 diff)
• validation/WayChecker.java (modified) (9 diffs)

applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/gui/PTAssistantLayer.java

@@ -194 +194 @@
         }
 
+
         @Override
         public void layerRemoving(LayerRemoveEvent event) {

applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/gui/PTAssistantPaintVisitor.java

@@ -10 +10 @@
 import java.util.HashMap;
 import java.util.List;
+
+import javax.swing.JOptionPane;
 
 import org.openstreetmap.josm.data.osm.Node;
@@ -202 +204 @@
                         double cosTriangle = 6 * Math.cos(t);
                         double sinTriangle = 6 * Math.sin(t);
-                        g.setColor(new Color(50, 50, 50));
+                        g.setColor(Color.WHITE);
 
                         if (oneway > 0) {

applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/utils/RouteUtils.java

@@ -1 +1 @@
 package org.openstreetmap.josm.plugins.pt_assistant.utils;
 
+import org.openstreetmap.josm.data.osm.Node;
 import org.openstreetmap.josm.data.osm.OsmPrimitiveType;
+import org.openstreetmap.josm.data.osm.OsmUtils;
 import org.openstreetmap.josm.data.osm.Relation;
 import org.openstreetmap.josm.data.osm.RelationMember;
+import org.openstreetmap.josm.data.osm.Way;
 
 /**
@@ -114 +117 @@
         }
 
+        /**
+         * Checks if the given way has tags that make it oneway for public
+         * transport. The test does not check whether the way violates those
+         * restrictions.
+         * 
+         * @return 0 if the way is not oneway for public transport, 1 if the way is
+         *         oneway for public transport, -1 if the way is reversely oneway
+         *         for public transport
+         */
+        public static int isOnewayForPublicTransport(Way way) {
+
+                if (OsmUtils.isTrue(way.get("oneway")) || OsmUtils.isReversed(way.get("oneway"))
+                                || way.hasTag("junction", "roundabout") || way.hasTag("highway", "motorway")) {
+
+                        if (!way.hasTag("busway", "lane") && !way.hasTag("busway:left", "lane")
+                                        && !way.hasTag("busway:right", "lane") && !way.hasTag("oneway:bus", "no")
+                                        && !way.hasTag("busway", "opposite_lane") && !way.hasTag("oneway:psv", "no")
+                                        && !way.hasTag("trolley_wire", "backward")) {
+
+                                if (OsmUtils.isReversed(way.get("oneway"))) {
+                                        return -1;
+                                }
+
+                                return 1;
+
+                        }
+
+                }
+
+                return 0;
+        }
+
+        public static boolean waysTouch(Way w1, Way w2) {
+
+                if (w1 == null || w2 == null) {
+                        return false;
+                }
+
+                Node w1FirstNode = w1.firstNode();
+                Node w1LastNode = w1.lastNode();
+                Node w2FirstNode = w2.firstNode();
+                Node w2LastNode = w2.lastNode();
+
+                if (w1FirstNode == w2FirstNode || w1FirstNode == w2LastNode || w1LastNode == w2FirstNode
+                                || w1LastNode == w2LastNode) {
+                        return true;
+                }
+
+                return false;
+        }
+
 }

applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/validation/Checker.java

@@ -57 +57 @@
 
                                 if (rm.getMember().hasTag("public_transport", "stop_position")) {
-//                                      if (!rm.hasRole("stop") && !rm.hasRole("stop_entry_only") && !rm.hasRole("stop_exit_only")) {
-//                                              RelationMember newMember = new RelationMember("stop", rm.getMember());
-//                                              resultList.add(newMember);
-//                                      } else {
+                                        if (!rm.hasRole("stop") && !rm.hasRole("stop_entry_only") && !rm.hasRole("stop_exit_only")) {
+                                                RelationMember newMember = new RelationMember("stop", rm.getMember());
+                                                resultList.add(newMember);
+                                        } else {
                                                 resultList.add(rm);
-//                                      }
+                                        }
                                 } else { // if platform
-//                                      if (!rm.hasRole("platform") && !rm.hasRole("platform_entry_only")
-//                                                      && !rm.hasRole("platform_exit_only")) {
-//                                              RelationMember newMember = new RelationMember("platform", rm.getMember());
-//                                              resultList.add(newMember);
-//                                      } else {
+                                        if (!rm.hasRole("platform") && !rm.hasRole("platform_entry_only")
+                                                        && !rm.hasRole("platform_exit_only")) {
+                                                RelationMember newMember = new RelationMember("platform", rm.getMember());
+                                                resultList.add(newMember);
+                                        } else {
                                                 resultList.add(rm);
-//                                      }
+                                        }
                                 }
 

applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/validation/WayChecker.java

@@ -7 +7 @@
 import java.util.List;
 
-import javax.swing.JOptionPane;
 import javax.swing.SwingUtilities;
 
@@ -16 +15 @@
 import org.openstreetmap.josm.command.SelectCommand;
 import org.openstreetmap.josm.command.SequenceCommand;
+import org.openstreetmap.josm.data.osm.Node;
 import org.openstreetmap.josm.data.osm.OsmPrimitive;
 import org.openstreetmap.josm.data.osm.OsmPrimitiveType;
-import org.openstreetmap.josm.data.osm.OsmUtils;
 import org.openstreetmap.josm.data.osm.Relation;
 import org.openstreetmap.josm.data.osm.RelationMember;
@@ -25 +24 @@
 import org.openstreetmap.josm.data.validation.Test;
 import org.openstreetmap.josm.data.validation.TestError;
-import org.openstreetmap.josm.gui.dialogs.relation.RelationDialogManager;
+import org.openstreetmap.josm.gui.dialogs.relation.GenericRelationEditor;
 import org.openstreetmap.josm.gui.dialogs.relation.RelationEditor;
-import org.openstreetmap.josm.gui.dialogs.relation.sort.WayConnectionType;
-import org.openstreetmap.josm.gui.dialogs.relation.sort.WayConnectionTypeCalculator;
 import org.openstreetmap.josm.gui.layer.OsmDataLayer;
 import org.openstreetmap.josm.plugins.pt_assistant.utils.RouteUtils;
@@ -40 +37 @@
  */
 public class WayChecker extends Checker {
-        
+
         public WayChecker(Relation relation, Test test) {
 
@@ -143 +140 @@
         protected void performDirectionTest() {
 
-                List<RelationMember> waysToCheck = new ArrayList<>();
+                List<Way> waysToCheck = new ArrayList<>();
 
                 for (RelationMember rm : relation.getMembers()) {
-                        if (RouteUtils.isPTWay(rm) && rm.getType().equals(OsmPrimitiveType.WAY)) {
-                                waysToCheck.add(rm);
-                        }
-                }
-
-                if (waysToCheck.isEmpty()) {
+                        if (RouteUtils.isPTWay(rm)) {
+                                if (rm.isWay()) {
+                                        waysToCheck.add(rm.getWay());
+                                } else {
+                                        Relation nestedRelation = rm.getRelation();
+                                        for (RelationMember nestedRelationMember : nestedRelation.getMembers()) {
+                                                waysToCheck.add(nestedRelationMember.getWay());
+                                        }
+                                }
+                        }
+                }
+
+                if (waysToCheck.size() <= 1) {
                         return;
                 }
 
-                WayConnectionTypeCalculator connectionTypeCalculator = new WayConnectionTypeCalculator();
-                final List<WayConnectionType> links = connectionTypeCalculator.updateLinks(waysToCheck);
-
-                for (int i = 0; i < links.size(); i++) {
-                        if ((OsmUtils.isTrue(waysToCheck.get(i).getWay().get("oneway"))
-                                        && links.get(i).direction.equals(WayConnectionType.Direction.BACKWARD))
-                                        || (OsmUtils.isReversed(waysToCheck.get(i).getWay().get("oneway"))
-                                                        && links.get(i).direction.equals(WayConnectionType.Direction.FORWARD))) {
-
-                                // At this point, the PTWay is going against the oneway
-                                // direction. Check if this road allows buses to disregard
-                                // the oneway restriction:
-
-                                if (!waysToCheck.get(i).getWay().hasTag("busway", "lane")
-                                                && !waysToCheck.get(i).getWay().hasTag("busway:left", "lane")
-                                                && !waysToCheck.get(i).getWay().hasTag("busway:right", "lane")
-                                                && !waysToCheck.get(i).getWay().hasTag("oneway:bus", "no")
-                                                && !waysToCheck.get(i).getWay().hasTag("busway", "opposite_lane")
-                                                && !waysToCheck.get(i).getWay().hasTag("oneway:psv", "no")
-                                                && !waysToCheck.get(i).getWay().hasTag("trolley_wire", "backward")) {
-                                        List<Relation> primitives = new ArrayList<>(1);
-                                        primitives.add(relation);
-                                        List<Way> highlighted = new ArrayList<>(1);
-                                        highlighted.add(waysToCheck.get(i).getWay());
-                                        TestError e = new TestError(this.test, Severity.WARNING,
-                                                        tr("PT: Route passes a oneway road in the wrong direction"),
-                                                        PTAssistantValidatorTest.ERROR_CODE_DIRECTION, primitives, highlighted);
-                                        this.errors.add(e);
-                                        return;
-                                }
-
-                        }
+                List<Way> problematicWays = new ArrayList<>();
+
+                for (int i = 0; i < waysToCheck.size(); i++) {
+
+                        Way curr = waysToCheck.get(i);
+
+                        if (i == 0) {
+                                // first way:
+                                Way next = waysToCheck.get(i + 1);
+                                if (!touchCorrectly(null, curr, next)) {
+                                        problematicWays.add(curr);
+                                }
+
+                        } else if (i == waysToCheck.size() - 1) {
+                                // last way:
+                                Way prev = waysToCheck.get(i - 1);
+                                if (!touchCorrectly(prev, curr, null)) {
+                                        problematicWays.add(curr);
+                                }
+
+                        } else {
+                                // all other ways:
+                                Way prev = waysToCheck.get(i - 1);
+                                Way next = waysToCheck.get(i + 1);
+                                if (!touchCorrectly(prev, curr, next)) {
+                                        problematicWays.add(curr);
+                                }
+                        }
+                }
+
+                for (Way problematicWay : problematicWays) {
+
+                        List<Relation> primitives = new ArrayList<>(1);
+                        primitives.add(relation);
+                        List<Way> highlighted = new ArrayList<>(1);
+                        highlighted.add(problematicWay);
+                        TestError e = new TestError(this.test, Severity.WARNING,
+                                        tr("PT: Route passes a oneway road in the wrong direction"),
+                                        PTAssistantValidatorTest.ERROR_CODE_DIRECTION, primitives, highlighted);
+                        this.errors.add(e);
                 }
 
@@ -283 +295 @@
                         return null;
                 }
-                
+
                 ArrayList<Command> commands = new ArrayList<>();
 
@@ -299 +311 @@
                 SelectCommand command2 = new SelectCommand(primitivesToZoom);
                 commands.add(command2);
-//
-//              List<RelationMember> sortedRelationMembers = listStopMembers(originalRelation);
-//              sortedRelationMembers.addAll(listNotStopMembers(originalRelation));
-//              originalRelation.setMembers(sortedRelationMembers);
-                
+
                 List<OsmDataLayer> listOfLayers = Main.getLayerManager().getLayersOfType(OsmDataLayer.class);
                 for (OsmDataLayer osmDataLayer : listOfLayers) {
@@ -309 +317 @@
 
                                 final OsmDataLayer layerParameter = osmDataLayer;
-//                              final Relation relationParameter = new Relation(originalRelation);
-//                              relationParameter.setMembers(sortedRelationMembers);
                                 final Relation relationParameter = originalRelation;
                                 final Collection<OsmPrimitive> zoomParameter = primitivesToZoom;
@@ -341 +347 @@
         private static void showRelationEditorAndZoom(OsmDataLayer layer, Relation r, Collection<OsmPrimitive> primitives) {
 
+                // zoom to problem:
                 AutoScaleAction.zoomTo(primitives);
-                RelationEditor editor = RelationEditor.getEditor(layer, r, r.getMembersFor(primitives));
+
+                // create editor:
+                GenericRelationEditor editor = (GenericRelationEditor) RelationEditor.getEditor(layer, r,
+                                r.getMembersFor(primitives));
+
+                // put stop-related members to the front and edit roles if necessary:
+                List<RelationMember> sortedRelationMembers = listStopMembers(r);
+                sortedRelationMembers.addAll(listNotStopMembers(r));
+                r.setMembers(sortedRelationMembers);
+                editor.reloadDataFromRelation();
+
+                // open editor:
                 editor.setVisible(true);
-                
-
+
+        }
+
+        /**
+         * Checks if the current way touches its neighbouring was correctly
+         * 
+         * @param prev
+         *            can be null
+         * @param curr
+         *            cannot be null
+         * @param next
+         *            can be null
+         * @return
+         */
+        private boolean touchCorrectly(Way prev, Way curr, Way next) {
+
+                if (RouteUtils.isOnewayForPublicTransport(curr) == 0) {
+                        return true;
+                }
+
+                if (prev != null) {
+
+                        if (RouteUtils.waysTouch(curr, prev)) {
+                                Node nodeInQuestion;
+                                if (RouteUtils.isOnewayForPublicTransport(curr) == 1) {
+                                        nodeInQuestion = curr.firstNode();
+                                } else {
+                                        nodeInQuestion = curr.lastNode();
+                                }
+
+                                if (nodeInQuestion != prev.firstNode() && nodeInQuestion != prev.lastNode()) {
+                                        return false;
+                                }
+                        }
+                }
+
+                if (next != null) {
+
+                        if (RouteUtils.waysTouch(curr, next)) {
+                                Node nodeInQuestion;
+                                if (RouteUtils.isOnewayForPublicTransport(curr) == 1) {
+                                        nodeInQuestion = curr.lastNode();
+                                } else {
+                                        nodeInQuestion = curr.firstNode();
+                                }
+
+                                if (nodeInQuestion != next.firstNode() && nodeInQuestion != next.lastNode()) {
+                                        return false;
+                                }
+                        }
+                }
+
+                return true;
 
         }