primitives. If successful, replies true, otherwise false.
+ *
+ * @param primitives the primitives
+ * @return true, if we can propose a U-turn restriction for the primitives
+ * in primitives
+ */
+ protected Relation initNoUTurnRestriction(ListReplies true, if the ways {@code w1} and {@code w2} are connected + * at the node {@code n}.
+ * + *If {@code w1} and {@code w2} intersect at the node {@code n}, + * this method replies false.
+ * + * @param w1 the first way + * @param w2 the second way + * @param n the node + * @return + */ + protected boolean isConnectingNode(Way w1, Way w2, Node n){ + if (isStartNode(w1, n)) { + return isStartNode(w2, n) | isEndNode(w2, n); + } else if (isEndNode(w1, n)){ + return isStartNode(w2, n) | isEndNode(w2, n); + } + return false; + } + + /** + * Replies true, if the way {@code w} is closed at the node {@code n}. + * + * @param w the way + * @param n the node + * @return true, if the way {@code w} is closed at the node {@code n}. + */ + protected boolean isClosedAt(Way w, Node n){ + ListDetermines the standard turn restriction between from way {@code w1} to + * way {@code w2}.
+ * + *Replies {@link TurnRestrictionType#NO_LEFT_TURN no_left_turn} or + * {@link TurnRestrictionType#NO_RIGHT_TURN no_right_turn}, if applicable. Or + * null, if neither of these restrictions is applicable, for instance because + * the passed in via node {@code via} isn't a node where the two ways are + * connected.
+ * + * @param w1 the "from"-way + * @param w2 the "to"-way + * @param via the via node + * @return an applicable turn restriction, or null, if no turn restriction is + * applicable + */ + protected String determineRestriction(Way w1, Way w2, Node via){ + if (via == null) return null; + if (!isConnectingNode(w1, w2, via)) return null; + // if either w1 or w2 are closed at the via node, we can't determine automatically + // whether the connection at "via" is a "left turn" or a "right turn" + if (isClosedAt(w1, via)) return null; + if (isClosedAt(w2, via)) return null; + + double phi1 = 0, phi2 = 0; + if (isEndNode(w1, via)){ + if (isStartNode(w2, via)) { + phi1 = phi(w1); + phi2 = phi(w2); + } else if (isEndNode(w2, via)){ + phi1 = phi(w1); + phi2 = phi(w2, true /* reverse it */); + } else { + assert false: "Unexpected state: via node is expected to be a start or and end node"; + } + } else if (isStartNode(w1,via)) { + if (isStartNode(w2, via)) { + phi1 = phi(w1, true /* reverse it */); + phi2 = phi(w2); + } else if (isEndNode(w2, via)){ + phi1 = phi(w1, true /* reverse it */); + phi2 = phi(w2, true /* reverse it */); + } else { + assert false: "Unexpected state: via node is expected to be a start or and end node"; + } + } else { + assert false: "Unexpected state: via node is expected to be a start or and end node of w1"; + } + + double phi = phi1-phi2; + if (phi >=0 && phi <= Math.PI) { + // looks like a right turn + return TurnRestrictionType.NO_RIGHT_TURN.getTagValue(); + } else { + // looks like a left turn + return TurnRestrictionType.NO_LEFT_TURN.getTagValue(); + } + } + + protected Relation initTurnRestrictionFromTwoWays(ListIssuesModel is a model for an observable list of {@code Issues} + * related to turn restriction.
* - * It is also an {@see Observer} to an {@see TurnRestrictionEditorModel} + *It is also an {@link Observer} to an {@link TurnRestrictionEditorModel} * and populates itself with issues it derives from the current state - * in the {@see TurnRestrictionEditorModel}. + * in the {@link TurnRestrictionEditorModel}.
* */ @@ -36,8 +36,4 @@ /** * Creates the model - * - * {@code controler} is used in resolution actions for issues in - * this model to direct the user to a specific input field in one - * of the editor tabs in order to fix an issue. * * @param editorModel the editor model. Must not be null. @@ -224,14 +220,19 @@ issues.add(new IntersectionMissingAsViaError(this, from, to, intersect)); } - } - - // 'from' intersects with 'to' - should be split - if (intersect != null && from.getNode(0) != intersect && from.getNode(from.getNodesCount()-1) != intersect){ - issues.add(new TurnRestrictionLegSplitRequiredError(this, TurnRestrictionLegRole.FROM, from, to, intersect)); - } - // 'to' intersects with 'from' - should be split - if (intersect != null && to.getNode(0) != intersect && to.getNode(to.getNodesCount()-1) != intersect){ - issues.add(new TurnRestrictionLegSplitRequiredError(this, TurnRestrictionLegRole.TO, from, to, intersect)); - } + // 'from' intersects with 'to' - should be split + if (from.getNode(0) != intersect && from.getNode(from.getNodesCount()-1) != intersect){ + issues.add(new TurnRestrictionLegSplitRequiredError(this, TurnRestrictionLegRole.FROM, from, to, intersect)); + } + // 'to' intersects with 'from' - should be split + if (to.getNode(0) != intersect && to.getNode(to.getNodesCount()-1) != intersect){ + issues.add(new TurnRestrictionLegSplitRequiredError(this, TurnRestrictionLegRole.TO, from, to, intersect)); + } + } else { + if (editorModel.getVias().isEmpty() && ! from.equals(to)){ + // the two turn restriction legs aren't connected and we don't have configured + // via objects + issues.add(new MissingViaError(this)); + } + } } Index: applications/editors/josm/plugins/turnrestrictions/src/org/openstreetmap/josm/plugins/turnrestrictions/qa/MissingViaError.java =================================================================== --- applications/editors/josm/plugins/turnrestrictions/src/org/openstreetmap/josm/plugins/turnrestrictions/qa/MissingViaError.java (revision 23571) +++ applications/editors/josm/plugins/turnrestrictions/src/org/openstreetmap/josm/plugins/turnrestrictions/qa/MissingViaError.java (revision 23571) @@ -0,0 +1,39 @@ +package org.openstreetmap.josm.plugins.turnrestrictions.qa; + +import static org.openstreetmap.josm.tools.I18n.tr; + +import java.awt.event.ActionEvent; + +import javax.swing.AbstractAction; + +/** + * Issue if the legs of a turn restriction aren't connected and if there + * are no via objects configured. + * + */ +public class MissingViaError extends Issue { + + public MissingViaError(IssuesModel parent) throws IllegalArgumentException { + super(parent, Severity.WARNING); + actions.add(new FixAction()); + } + + @Override + public String getText() { + String msg = + tr("The two ways participating in the turn restriction aren''t connected.") + + ""
+ + tr("Make sure you add one or more via objects (nodes or ways) to the turn restriction.");
+ return msg;
+ }
+
+ class FixAction extends AbstractAction {
+ public FixAction() {
+ putValue(NAME, tr("Fix in editor"));
+ putValue(SHORT_DESCRIPTION, tr("Go to the Advanced Editor and add via objects"));
+ }
+ public void actionPerformed(ActionEvent e) {
+ getIssuesModel().getNavigationControler().gotoAdvancedEditor();
+ }
+ }
+}
Index: applications/editors/josm/plugins/turnrestrictions/test/src/org/openstreetmap/josm/plugins/turnrestrictions/AllUnitTests.java
===================================================================
--- applications/editors/josm/plugins/turnrestrictions/test/src/org/openstreetmap/josm/plugins/turnrestrictions/AllUnitTests.java (revision 23568)
+++ applications/editors/josm/plugins/turnrestrictions/test/src/org/openstreetmap/josm/plugins/turnrestrictions/AllUnitTests.java (revision 23571)
@@ -1,14 +1,12 @@
package org.openstreetmap.josm.plugins.turnrestrictions;
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
import org.openstreetmap.josm.plugins.turnrestrictions.editor.AllEditorTests;
-import junit.framework.Test;
-import junit.framework.TestSuite;
-
-public class AllUnitTests {
- public static Test suite() throws Exception {
- TestSuite suite = new TestSuite(AllUnitTests.class.getName());
- suite.addTest(AllEditorTests.suite());
- return suite;
- }
-}
+@RunWith(Suite.class)
+@Suite.SuiteClasses({
+ AllEditorTests.class,
+ TurnRestrictionBuilderTest.class
+})
+public class AllUnitTests {}
Index: applications/editors/josm/plugins/turnrestrictions/test/src/org/openstreetmap/josm/plugins/turnrestrictions/TurnRestrictionBuilderTest.groovy
===================================================================
--- applications/editors/josm/plugins/turnrestrictions/test/src/org/openstreetmap/josm/plugins/turnrestrictions/TurnRestrictionBuilderTest.groovy (revision 23571)
+++ applications/editors/josm/plugins/turnrestrictions/test/src/org/openstreetmap/josm/plugins/turnrestrictions/TurnRestrictionBuilderTest.groovy (revision 23571)
@@ -0,0 +1,350 @@
+package org.openstreetmap.josm.plugins.turnrestrictions;
+import groovy.util.GroovyTestCase;
+
+import static org.junit.Assert.*;
+import org.junit.*;
+import org.openstreetmap.josm.data.osm.Node;
+import org.openstreetmap.josm.data.osm.Way;
+import org.openstreetmap.josm.data.osm.Relation;
+import org.openstreetmap.josm.data.osm.RelationMember;
+import org.openstreetmap.josm.plugins.turnrestrictions.fixtures.JOSMFixture;
+import org.openstreetmap.josm.data.coor.LatLon;
+
+class TurnRestrictionBuilderTest{
+
+ def TurnRestrictionBuilder builder;
+
+ def boolean hasExactlyOneMemberWithRole(Relation r, String role ){
+ return r.getMembers().find {RelationMember rm -> rm.getRole() == role} != null
+ }
+
+ def memberWithRole(Relation r, String role) {
+ def RelationMember rm = r.getMembers().find {RelationMember rm -> rm.getRole() == role}
+ return rm.getMember()
+ }
+
+ def void assertEmptyTurnRestriction(Relation r){
+ assert r != null
+ assert r.get("type") == "restriction"
+ assert r.getMembersCount() == 0
+ }
+
+ @Before
+ 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)
+ }
+ }
+ }
+
+ /**
+ * Selection consist of one way and the start node of the way ->
+ * propose a No-U-Turn restriction
+ *
+ */
+ @Test
+ public void noUTurn_1() {
+ Way w = new Way(1)
+ Node n1 = new Node(1)
+ Node n2 = new Node(2)
+ w.setNodes([n1,n2])
+
+ def sel = [w,n1]
+ TurnRestrictionBuilder builder = new TurnRestrictionBuilder()
+ Relation r = builder.build(sel)
+
+ assert r != null
+ assert r.getMembersCount() == 3
+ assert hasExactlyOneMemberWithRole(r, "from")
+ assert hasExactlyOneMemberWithRole(r, "to")
+ assert hasExactlyOneMemberWithRole(r, "via")
+ assert memberWithRole(r, "from") == w
+ assert memberWithRole(r, "to") == w
+ assert memberWithRole(r, "via") == n1
+ assert r.get("restriction") == "no_u_turn"
+ }
+
+
+ /**
+ * Selection consist of one way and the end node of the way ->
+ * propose a No-U-Turn restriction
+ *
+ */
+ @Test
+ public void noUTurn_2() {
+ Way w = new Way(1)
+ Node n1 = new Node(1)
+ Node n2 = new Node(2)
+ w.setNodes([n1,n2])
+
+ def sel = [w,n2]
+ TurnRestrictionBuilder builder = new TurnRestrictionBuilder()
+ Relation r = builder.build(sel)
+
+ assert r != null
+ assert r.getMembersCount() == 3
+ assert hasExactlyOneMemberWithRole(r, "from")
+ assert hasExactlyOneMemberWithRole(r, "to")
+ assert hasExactlyOneMemberWithRole(r, "via")
+ assert memberWithRole(r, "from") == w
+ assert memberWithRole(r, "to") == w
+ assert memberWithRole(r, "via") == n2
+ assert r.get("restriction") == "no_u_turn"
+ }
+
+ @Test
+ public void nullSelection() {
+ def tr = builder.build(null)
+ assertEmptyTurnRestriction(tr)
+ }
+
+ @Test
+ public void emptySelection() {
+ def tr = builder.build([])
+ assertEmptyTurnRestriction(tr)
+ }
+
+ /**
+ * One selected way -> build a turn restriction with a "from" leg
+ * only
+ */
+ @Test
+ public void oneSelectedWay() {
+ Way w = new Way(1)
+ Relation tr = builder.build([w])
+ assert tr != null
+ assert tr.get("type") == "restriction"
+ assert tr.getMembersCount() == 1
+ assert memberWithRole(tr, "from") == w
+ }
+
+ /**
+ * Two unconnected ways in the selection. The first one becomes the from leg,
+ * the second one the two leg.
+ */
+ @Test
+ public void twoUnconnectedWays() {
+ Way w1 = new Way(1)
+ w1.setNodes([new Node(11), new Node(12)])
+ Way w2 = new Way(2)
+ w2.setNodes([new Node(21), new Node(22)])
+
+ Relation tr = builder.build([w1,w2])
+ assert tr != null
+ assert tr.get("type") == "restriction"
+ assert ! tr.hasKey("restriction")
+ assert tr.getMembersCount() == 2
+ assert memberWithRole(tr, "from") == w1
+ assert memberWithRole(tr, "to") == w2
+ }
+
+ /**
+ * Two connected ways. end node of the first way connects to start node of
+ * the second way.
+ * w2
+ * -------->
+ * ^
+ * | w1
+ * |
+ */
+ @Test
+ public void twoConnectedWays_1() {
+ Node n1 = new Node(1)
+ n1.setCoor(new LatLon(1,1))
+ Node n2 = new Node(2)
+ n2.setCoor(new LatLon(2,1))
+ Node n3 = new Node(3)
+ n3.setCoor(new LatLon(2,2))
+
+ Way w1 = new Way(1)
+ w1.setNodes([n1,n2])
+ Way w2 = new Way(2)
+ w2.setNodes([n2,n3])
+
+ assert builder.testPhi(w1) == Math.toRadians(90)
+ assert builder.testPhi(w2) == Math.toRadians(0)
+
+ Relation tr = builder.build([w1,w2,n2])
+
+ assert tr != null
+ assert tr.get("type") == "restriction"
+ assert tr.getMembersCount() == 3
+ assert memberWithRole(tr, "from") == w1
+ assert memberWithRole(tr, "to") == w2
+ assert memberWithRole(tr, "via") == n2
+
+ assert tr.get("restriction") == "no_right_turn"
+
+ /*
+ * opposite order, from w2 to w1. In this case we have left turn.
+ */
+
+ tr = builder.build([w2,w1,n2])
+
+ assert tr != null
+ assert tr.get("type") == "restriction"
+ assert tr.getMembersCount() == 3
+ assert memberWithRole(tr, "from") == w2
+ assert memberWithRole(tr, "to") == w1
+ assert memberWithRole(tr, "via") == n2
+
+ assert tr.get("restriction") == "no_left_turn"
+ }
+
+ /**
+ * Two connected ways. end node of the first way connects to end node of
+ * the second way. left turn.
+ *
+ * w2
+ * (7,2) -------> (7,5)
+ * ^
+ * | w1
+ * |
+ * (5,5)
+ */
+ @Test
+ public void twoConnectedWays_2() {
+ Node n1 = new Node(1)
+ n1.setCoor(new LatLon(5,5))
+ Node n2 = new Node(2)
+ n2.setCoor(new LatLon(7,5))
+ Node n3 = new Node(3)
+ n3.setCoor(new LatLon(7,2))
+
+ Way w1 = new Way(1)
+ w1.setNodes([n1,n2])
+ Way w2 = new Way(2)
+ 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)
+
+ Relation tr = builder.build([w1,w2,n2])
+
+ assert tr != null
+ assert tr.get("type") == "restriction"
+ assert tr.getMembersCount() == 3
+ assert memberWithRole(tr, "from") == w1
+ assert memberWithRole(tr, "to") == w2
+ assert memberWithRole(tr, "via") == n2
+
+ assert tr.get("restriction") == "no_left_turn"
+
+
+ /*
+ * opposite order, from w2 to w1. In this case we have right turn.
+ */
+ tr = builder.build([w2,w1,n2])
+
+ assert tr != null
+ assert tr.get("type") == "restriction"
+ assert tr.getMembersCount() == 3
+ assert memberWithRole(tr, "from") == w2
+ assert memberWithRole(tr, "to") == w1
+ assert memberWithRole(tr, "via") == n2
+ assert tr.get("restriction") == "no_right_turn"
+ }
+
+ /**
+ * Two connected ways. end node of the first way connects to end node of
+ * the second way. left turn.
+ *
+ *
+ * (7,5) -
+ * ^ - w2
+ * | w1 ------> (6,7)
+ * |
+ * (5,5)
+ */
+ @Test
+ public void twoConnectedWays_3() {
+ Node n1 = new Node(1)
+ n1.setCoor(new LatLon(5,5))
+ Node n2 = new Node(2)
+ n2.setCoor(new LatLon(7,5))
+ Node n3 = new Node(3)
+ n3.setCoor(new LatLon(6,7))
+
+ Way w1 = new Way(1)
+ w1.setNodes([n1,n2])
+ Way w2 = new Way(2)
+ w2.setNodes([n2,n3])
+
+ Relation tr = builder.build([w1,w2,n2])
+
+ assert tr != null
+ assert tr.get("type") == "restriction"
+ assert tr.getMembersCount() == 3
+ assert memberWithRole(tr, "from") == w1
+ assert memberWithRole(tr, "to") == w2
+ assert memberWithRole(tr, "via") == n2
+
+ assert tr.get("restriction") == "no_right_turn"
+ }
+
+
+ /**
+ * Two connected ways. end node of the first way connects to end node of
+ * the second way. left turn.
+ *
+ *
+ * (10,10)
+ * \
+ * \
+ * \
+ * v
+ * (8,15)
+ * /
+ * /
+ * /
+ * v
+ * (5,11)
+ */
+ @Test
+ public void twoConnectedWays_4() {
+ Node n1 = new Node(1)
+ n1.setCoor(new LatLon(10,10))
+ Node n2 = new Node(2)
+ n2.setCoor(new LatLon(8,15))
+ Node n3 = new Node(3)
+ n3.setCoor(new LatLon(5,11))
+
+ Way w1 = new Way(1)
+ w1.setNodes([n1,n2])
+ Way w2 = new Way(2)
+ w2.setNodes([n2,n3])
+
+ Relation tr = builder.build([w1,w2,n2])
+
+ assert tr != null
+ assert tr.get("type") == "restriction"
+ assert tr.getMembersCount() == 3
+ assert memberWithRole(tr, "from") == w1
+ assert memberWithRole(tr, "to") == w2
+ assert memberWithRole(tr, "via") == n2
+
+ assert tr.get("restriction") == "no_right_turn"
+
+
+ /*
+ * opposite order, from w2 to w1. In this case we have left turn.
+ */
+ tr = builder.build([w2,w1,n2])
+
+ assert tr != null
+ assert tr.get("type") == "restriction"
+ assert tr.getMembersCount() == 3
+ assert memberWithRole(tr, "from") == w2
+ assert memberWithRole(tr, "to") == w1
+ assert memberWithRole(tr, "via") == n2
+
+ assert tr.get("restriction") == "no_left_turn"
+ }
+}
Index: applications/editors/josm/plugins/turnrestrictions/test/src/org/openstreetmap/josm/plugins/turnrestrictions/editor/AllEditorTests.java
===================================================================
--- applications/editors/josm/plugins/turnrestrictions/test/src/org/openstreetmap/josm/plugins/turnrestrictions/editor/AllEditorTests.java (revision 23568)
+++ applications/editors/josm/plugins/turnrestrictions/test/src/org/openstreetmap/josm/plugins/turnrestrictions/editor/AllEditorTests.java (revision 23571)
@@ -1,26 +1,17 @@
package org.openstreetmap.josm.plugins.turnrestrictions.editor;
-import groovy.util.GroovyTestSuite;
-import junit.framework.Test;
import junit.framework.TestCase;
-import junit.framework.TestSuite;
-public class AllEditorTests extends TestCase{
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
- private static final String TEST_ROOT = "test/src/org/openstreetmap/josm/plugins/turnrestrictions/editor/";
- private static final GroovyTestSuite gsuite = new GroovyTestSuite();
-
- private static