Changeset 23593 in osm for applications/editors/josm/plugins/turnrestrictions/test/src

Timestamp:

2010-10-13T19:05:12+02:00 (14 years ago)

Author:

guggis

Message:

Fixed #5522 - Plug-in turn restriction is adding the wrong part of a splitted "to"-way to the relation
Changed the expression "OSM way", "OSM node", and "OSM relation" to "way", "node", and "relation" respectively. Translators should follow up and fix the translations in Launchpad.

File:

• applications/editors/josm/plugins/turnrestrictions/test/src/org/openstreetmap/josm/plugins/turnrestrictions/TurnRestrictionBuilderTest.groovy (modified) (8 diffs)

applications/editors/josm/plugins/turnrestrictions/test/src/org/openstreetmap/josm/plugins/turnrestrictions/TurnRestrictionBuilderTest.groovy

@@ -1 +1 @@
 package org.openstreetmap.josm.plugins.turnrestrictions;
+
+import java.util.Arrays;
+
 import groovy.util.GroovyTestCase;
 
@@ -10 +13 @@
 import org.openstreetmap.josm.plugins.turnrestrictions.fixtures.JOSMFixture;
 import org.openstreetmap.josm.data.coor.LatLon;
+import static org.openstreetmap.josm.plugins.turnrestrictions.TurnRestrictionBuilder.*
+import org.openstreetmap.josm.plugins.turnrestrictions.editor.TurnRestrictionType;
 
 class TurnRestrictionBuilderTest{
@@ -33 +38 @@
         public void setUp() {
                 JOSMFixture.createUnitTestFixture().init()
-                builder = new TurnRestrictionBuilder() {
-                        def double testPhi(Way w){
-                                return super.phi(w)
-                        }
-                        
-                        def double testPhi(Way w, boolean doRevert){
-                                return super.phi(w,doRevert)
-                        }
-                }
+                builder = new TurnRestrictionBuilder()
         }
 
@@ -168 +165 @@
            w2.setNodes([n2,n3])
 
-           assert builder.testPhi(w1) == Math.toRadians(90)        
-           assert builder.testPhi(w2) == Math.toRadians(0)
+           assert builder.phi(w1) == Math.toRadians(90)    
+           assert builder.phi(w2) == Math.toRadians(0)
                    
            Relation tr = builder.build([w1,w2,n2])
@@ -187 +184 @@
            
            tr = builder.build([w2,w1,n2])
+           
+           double a = interesectionAngle(w2, w1)
+           println "a=" + Math.toDegrees(a)
            
            assert tr != null
@@ -223 +223 @@
            w2.setNodes([n3,n2])
            
-           assert builder.testPhi(w1) == Math.toRadians(90)
-           assert builder.testPhi(w2) == Math.toRadians(0)
-           assert builder.testPhi(w2,true) == Math.toRadians(180)
+           assert builder.phi(w1) == Math.toRadians(90)
+           assert builder.phi(w2) == Math.toRadians(0)
+           assert builder.phi(w2,true) == Math.toRadians(180)
            
            Relation tr = builder.build([w1,w2,n2])
@@ -237 +237 @@
            
            assert tr.get("restriction") == "no_left_turn"
-           
            
            /*
@@ -348 +347 @@
          assert tr.get("restriction") == "no_left_turn"
         }
+ 
+ 
+    def Node nn(id, lat, lon) {
+                Node n = new Node(id)
+                n.setCoor(new LatLon(lat, lon))
+                return n
+    }
+        
+        def Way nw(id, Node... nodes) {
+                Way w = new Way(id)
+                w.setNodes(Arrays.asList(nodes))
+                return w
+        }
+ 
+        /** 
+         *                              n3
+         *                           (10,10)
+         *                             ^
+         *                             | to
+         *      n1      from           |
+         *    (5,5) -------------->  (5,10) n2
+         */
+         @Test
+         public void intersectionAngle_1() {
+                 Node n1 = nn(1,5,5)
+                 Node n2 = nn(2,5,10)
+                 Node n3 = nn(3,10,10)
+                 Way from = nw(1,n1,n2)
+                 Way to = nw(2,n2,n3)
+                 
+                 double a = TurnRestrictionBuilder.interesectionAngle(from, to)
+                 RelativeWayJoinOrientation o = TurnRestrictionBuilder.determineWayJoinOrientation(from,to)
+                 assert Math.toDegrees(a) == -90
+                 assert o == RelativeWayJoinOrientation.LEFT
+                 
+                 /*
+                  * if reversed from, the intersection angle is still -90°
+                  */
+                 from = nw(1,n2,n1)
+                 to = nw(2,n2,n3)
+                 a = TurnRestrictionBuilder.interesectionAngle(from, to)
+                 o = TurnRestrictionBuilder.determineWayJoinOrientation(from,to)
+                 assert Math.toDegrees(a) == -90
+                 assert o == RelativeWayJoinOrientation.LEFT
+
+                 /*
+                 * if reversed to, the intersection angle is still -90°
+                 */
+                 from = nw(1,n1,n2)
+                 to = nw(2,n3,n2)
+                 a = TurnRestrictionBuilder.interesectionAngle(from, to)
+                 o = TurnRestrictionBuilder.determineWayJoinOrientation(from,to)
+                 assert Math.toDegrees(a) == -90
+                 assert o == RelativeWayJoinOrientation.LEFT
+
+                 /*
+                 * if reversed both, the intersection angle is still -90°
+                 */
+                 from = nw(1,n2,n1)
+                 to = nw(2,n3,n2)
+                 a = TurnRestrictionBuilder.interesectionAngle(from, to)
+                 o = TurnRestrictionBuilder.determineWayJoinOrientation(from,to)
+                 assert Math.toDegrees(a) == -90
+                 assert o == RelativeWayJoinOrientation.LEFT
+         }
+         
+         /**
+         *      n1      from           
+         *    (5,5) -------------->  (5,10) n2
+         *                              |
+         *                              | to
+         *                              |
+         *                              v
+         *                            (2,10)
+         *                              n3
+         *    
+         */
+        @Test
+        public void intersectionAngle_2() {
+                Node n1 = nn(1,5,5)
+                Node n2 = nn(2,5,10)
+                Node n3 = nn(3,2,10)
+                Way from = nw(1,n1,n2)
+                Way to = nw(2,n2,n3)
+                
+                double a = TurnRestrictionBuilder.interesectionAngle(from, to)
+                assert Math.toDegrees(a) == 90
+                
+                /*
+                 * if reversed from, the intersection angle is still 90°
+                 */
+                from = nw(1,n2,n1)
+                to = nw(2,n2,n3)
+                a = TurnRestrictionBuilder.interesectionAngle(from, to)
+                assert Math.toDegrees(a) == 90
+
+                /*
+                * if reversed to, the intersection angle is still 90°
+                */
+                from = nw(1,n1,n2)
+                to = nw(2,n3,n2)
+                a = TurnRestrictionBuilder.interesectionAngle(from, to)
+                assert Math.toDegrees(a) == 90
+
+                /*
+                * if reversed both, the intersection angle is still 90°
+                */
+                from = nw(1,n2,n1)
+                to = nw(2,n3,n2)
+                a = TurnRestrictionBuilder.interesectionAngle(from, to)
+                assert Math.toDegrees(a) == 90
+        }
+        
+        
+        /**
+         * 
+         *                       
+         *             (-1,-6) (n3)
+         *             ^
+         *            /
+         *           /  to
+         *          /
+         *      (-5, -10) n2
+    *           ^
+        *           |
+        *           | from 
+        *           |
+        *       (-10,-10) n1 
+        */
+   @Test
+   public void intersectionAngle_3() {
+           Node n1 = nn(1,-10,-10)
+           Node n2 = nn(2,-5,-10)
+           Node n3 = nn(3,-1,-6)
+           Way from = nw(1,n1,n2)
+           Way to = nw(2,n2,n3)
+           
+           double a = TurnRestrictionBuilder.interesectionAngle(from, to)
+           assert Math.toDegrees(a) == 45
+           
+           /*
+                * if reversed from, the intersection angle is still 45
+                */
+           from = nw(1,n2,n1)
+           to = nw(2,n2,n3)
+           a = TurnRestrictionBuilder.interesectionAngle(from, to)
+           assert Math.toDegrees(a) == 45
+
+           /*
+           * if reversed to, the intersection angle is still 45
+           */
+           from = nw(1,n1,n2)
+           to = nw(2,n3,n2)
+           a = TurnRestrictionBuilder.interesectionAngle(from, to)
+           assert Math.toDegrees(a) == 45
+
+           /*
+           * if reversed both, the intersection angle is still 45
+           */
+           from = nw(1,n2,n1)
+           to = nw(2,n3,n2)
+           a = TurnRestrictionBuilder.interesectionAngle(from, to)
+           assert Math.toDegrees(a) == 45
+   }
+   
+   /**
+   *
+   *
+   *         (-1,-14) (n3)
+   *            ^
+   *            \
+   *             \ to
+   *              \
+   *          (-5, -10) n2
+  *               ^
+  *               |
+  *               | from
+  *               |
+  *           (-10,-10) n1
+  */
+ @Test
+ public void intersectionAngle_4() {
+         Node n1 = nn(1,-10,-10)
+         Node n2 = nn(2,-5,-10)
+         Node n3 = nn(3,-1,-14)
+         Way from = nw(1,n1,n2)
+         Way to = nw(2,n2,n3)
+         
+         double a = TurnRestrictionBuilder.interesectionAngle(from, to)
+         assert Math.toDegrees(a) == -45
+         
+         /*
+          * if reversed from, the intersection angle is still -45
+          */
+         from = nw(1,n2,n1)
+         to = nw(2,n2,n3)
+         a = TurnRestrictionBuilder.interesectionAngle(from, to)
+         assert Math.toDegrees(a) == -45
+
+         /*
+         * if reversed to, the intersection angle is still -45
+         */
+         from = nw(1,n1,n2)
+         to = nw(2,n3,n2)
+         a = TurnRestrictionBuilder.interesectionAngle(from, to)
+         assert Math.toDegrees(a) == -45
+
+         /*
+         * if reversed both, the intersection angle is still 45
+         */
+         from = nw(1,n2,n1)
+         to = nw(2,n3,n2)
+         a = TurnRestrictionBuilder.interesectionAngle(from, to)
+         assert Math.toDegrees(a) == -45
+ }
+ 
+ 
+         /*
+         *
+         *      n21        w21        n22       w22            n23
+         *    (10,10)-------------> (10,15) -------------- > (10,20)
+         *                            ^
+         *                            |
+         *                            | w1
+         *                            |
+         *                          (5,15)
+         *                            n11
+         */
+        @Test
+        public void splitToWay() {
+                Node n11 = new Node(11);
+                n11.setCoor(new LatLon(5,15));
+                
+                Node n21 = new Node(21)
+                n21.setCoor(new LatLon(10,10))
+                Node n22 = new Node(22)
+                n22.setCoor(new LatLon(10,15))
+                Node n23 = new Node(23)
+                n23.setCoor(new LatLon(10,20))
+                
+                Way w1 = new Way(1)
+                w1.setNodes([n11,n22])
+                Way w21 = new Way(21)
+                w21.setNodes([n21,n22])
+                Way w22 = new Way(22)
+                w22.setNodes([n22,n23])
+        
+                Way adjustedTo = selectToWayAfterSplit(
+                        w1,
+                        w21,
+                        w22,
+                        TurnRestrictionType.NO_LEFT_TURN
+                )
+                
+                assert adjustedTo != null
+                assert adjustedTo == w21
+                
+                adjustedTo = selectToWayAfterSplit(
+                        w1,
+                        w21,
+                        w22,
+                        TurnRestrictionType.NO_RIGHT_TURN
+                )
+                
+                assert adjustedTo != null
+                assert adjustedTo == w22
+                
+                adjustedTo = selectToWayAfterSplit(
+                        w1,
+                        w21,
+                        w22,
+                        TurnRestrictionType.ONLY_LEFT_TURN
+                )
+                
+                assert adjustedTo != null
+                assert adjustedTo == w21
+                
+                adjustedTo = selectToWayAfterSplit(
+                        w1,
+                        w21,
+                        w22,
+                        TurnRestrictionType.ONLY_RIGHT_TURN
+                )
+                
+                assert adjustedTo != null
+                assert adjustedTo == w22
+                
+                adjustedTo = selectToWayAfterSplit(
+                        w1,
+                        w21,
+                        w22,
+                        TurnRestrictionType.NO_STRAIGHT_ON
+                )
+                
+                assert adjustedTo == null
+        }       
 }