Changeset 8303 in josm

Timestamp:

2015-05-01T21:33:01+02:00 (9 years ago)

Author:

Balaitous

Message:

fix #7421 - Circle created from way heads always clockwise

• If 3 nodes closed way is selected, keep way direction when creating circle;
• Otherwise use left- and right-hand traffic database (r7193) to determine way direction;
• Add a Geometry.isClockwise(List<Node>) method;
• Fix some sonar issue
• Add test case

Location:

trunk

Files:

• src/org/openstreetmap/josm/actions/CreateCircleAction.java (modified) (7 diffs)
• src/org/openstreetmap/josm/tools/Geometry.java (modified) (1 diff)
• test/unit/org/openstreetmap/josm/actions/CreateCircleActionTest.java (added)

trunk/src/org/openstreetmap/josm/actions/CreateCircleAction.java

@@ -10 +10 @@
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.Comparator;
 import java.util.LinkedList;
@@ -28 +29 @@
 import org.openstreetmap.josm.gui.Notification;
 import org.openstreetmap.josm.tools.Geometry;
+import org.openstreetmap.josm.tools.RightAndLefthandTraffic;
 import org.openstreetmap.josm.tools.Shortcut;
 
@@ -115 +117 @@
         @Override
         public int compare(PolarNode pc1, PolarNode pc2) {
-            if(pc1.a < pc2.a)
-                return -1;
-            else if(pc1.a == pc2.a)
-                return 0;
-            else
-                return 1;
+            return Double.compare(pc1.a, pc2.a);
         }
     }
@@ -137 +134 @@
 
         Collection<OsmPrimitive> sel = getCurrentDataSet().getSelected();
-        List<Node> nodes = new LinkedList<>();
+        List<Node> nodes = OsmPrimitive.getFilteredList(sel, Node.class);
+        List<Way> ways = OsmPrimitive.getFilteredList(sel, Way.class);
+
         Way existingWay = null;
-
-        for (OsmPrimitive osm : sel)
-            if (osm instanceof Node) {
-                nodes.add((Node)osm);
-            }
 
         // special case if no single nodes are selected and exactly one way is:
         // then use the way's nodes
-        if (nodes.isEmpty() && (sel.size() == 1)) {
-            for (OsmPrimitive osm : sel)
-                if (osm instanceof Way) {
-                    existingWay = ((Way)osm);
-                    for (Node n : ((Way)osm).getNodes())
-                    {
-                        if(!nodes.contains(n)) {
-                            nodes.add(n);
-                        }
-                    }
+        if (nodes.isEmpty() && (ways.size() == 1)) {
+            existingWay = ways.get(0);
+            for (Node n : existingWay.getNodes()) {
+                if(!nodes.contains(n)) {
+                    nodes.add(n);
                 }
+            }
         }
 
@@ -210 +200 @@
 
         // build a way for the circle
-        List<Node> wayToAdd = new ArrayList<>();
+        List<Node> nodesToAdd = new ArrayList<>();
         for(int i = 0; i < nodes.size(); i++) {
-            wayToAdd.add(angles[i].node);
+            nodesToAdd.add(angles[i].node);
             double delta = angles[(i+1) % nodes.size()].a - angles[i].a;
             if(delta < 0)
@@ -226 +216 @@
                 }
                 Node n = new Node(ll);
-                wayToAdd.add(n);
+                nodesToAdd.add(n);
                 cmds.add(new AddCommand(n));
             }
         }
-        wayToAdd.add(wayToAdd.get(0)); // close the circle
+        nodesToAdd.add(nodesToAdd.get(0)); // close the circle
+        if (existingWay != null && existingWay.getNodesCount() >= 3) {
+            nodesToAdd = orderNodesByWay(nodesToAdd, existingWay);
+        } else {
+            nodesToAdd = orderNodesByTrafficHand(nodesToAdd);
+        }
         if (existingWay == null) {
             Way newWay = new Way();
-            newWay.setNodes(wayToAdd);
+            newWay.setNodes(nodesToAdd);
             cmds.add(new AddCommand(newWay));
         } else {
             Way newWay = new Way(existingWay);
-            newWay.setNodes(wayToAdd);
+            newWay.setNodes(nodesToAdd);
             cmds.add(new ChangeCommand(existingWay, newWay));
         }
@@ -243 +238 @@
         Main.main.undoRedo.add(new SequenceCommand(tr("Create Circle"), cmds));
         Main.map.repaint();
+    }
+
+    /**
+     * Order nodes according to left/right hand traffic.
+     * @param nodes Nodes list to be ordered.
+     * @return Modified nodes list ordered according hand traffic.
+     */
+    private List<Node> orderNodesByTrafficHand(List<Node> nodes) {
+        boolean rightHandTraffic = true;
+        for (Node n: nodes) {
+            if (!RightAndLefthandTraffic.isRightHandTraffic(n.getCoor())) {
+                rightHandTraffic = false;
+                break;
+            }
+        }
+        if (rightHandTraffic == Geometry.isClockwise(nodes)) {
+            Collections.reverse(nodes);
+        }
+        return nodes;
+    }
+
+    /**
+     * Order nodes according to way direction.
+     * @param nodes Nodes list to be ordered.
+     * @param way Way used to determine direction.
+     * @return Modified nodes list with same direction as way.
+     */
+    private List<Node> orderNodesByWay(List<Node> nodes, Way way) {
+        List<Node> wayNodes = way.getNodes();
+        if (!way.isClosed()) {
+            wayNodes.add(wayNodes.get(0));
+        }
+        if (Geometry.isClockwise(wayNodes) != Geometry.isClockwise(nodes)) {
+            Collections.reverse(nodes);
+        }
+        return nodes;
     }
 

trunk/src/org/openstreetmap/josm/tools/Geometry.java

@@ -688 +688 @@
      */
     public static boolean isClockwise(Way w) {
-        if (!w.isClosed()) {
+        return isClockwise(w.getNodes());
+    }
+
+    /**
+     * Determines whether path from nodes list is oriented clockwise.
+     * @see #isClockwise(Way)
+     * @param nodes Nodes list to be checked.
+     * @return true if and only if way is oriented clockwise.
+     * @throws IllegalArgumentException if way is not closed (see {@link Way#isClosed}).
+     */
+    public static boolean isClockwise(List<Node> nodes) {
+        double area2 = 0.;
+        int nodesCount = nodes.size();
+        if (nodesCount < 3 || nodes.get(0) != nodes.get(nodesCount - 1)) {
             throw new IllegalArgumentException("Way must be closed to check orientation.");
         }
 
-        double area2 = 0.;
-        int nodesCount = w.getNodesCount();
-
         for (int node = 1; node <= /*sic! consider last-first as well*/ nodesCount; node++) {
-            LatLon coorPrev = w.getNode(node - 1).getCoor();
-            LatLon coorCurr = w.getNode(node % nodesCount).getCoor();
+            LatLon coorPrev = nodes.get(node - 1).getCoor();
+            LatLon coorCurr = nodes.get(node % nodesCount).getCoor();
             area2 += coorPrev.lon() * coorCurr.lat();
             area2 -= coorCurr.lon() * coorPrev.lat();