Replies the angle phi in the polar coordinates (r,phi) representing the first + * segment of the way {@code w}, where w is moved such that the start node of {@code w} is + * in the origin (0,0).
+ * + *If {@code doInvert} is true, computes phi for the way in reversed direction.
+ * + * @param w the way. Must not be null. At least two nodes required. + * @param doInvert if true, computes phi for the reversed way + * @return phi in the polar coordinates + * @throws IllegalArgumentException thrown if w is null + * @throws IllegalArgumentException thrown if w is too short (at least two nodes required) + */ + static public double phi(Way w, boolean doInvert) throws IllegalArgumentException { + CheckParameterUtil.ensureParameterNotNull(w, "w"); + if (w.getNodesCount() < 2) { + throw new IllegalArgumentException("can't compute phi for way with less than 2 nodes"); + } + ListReplies the angle at which way {@code from} and {@code to} are connected + * at exactly one common node.
+ * + *If the result is positive, the way {@code from} bends to the right, if it + * is negative, the {@code to} bends to the left.
+ * + *The two ways must not be null and they must be connected at exactly one + * common node. They must not intersect at this node.
. + * + * @param from the from way + * @param to the to way + * @return the intersection angle + * @throws IllegalArgumentException thrown if the two nodes don't have exactly one common + * node at which they are connected + * + */ + static public double interesectionAngle(Way from, Way to) throws IllegalArgumentException { + Node via = getUniqueCommonNode(from, to); + if (via == null) + throw new IllegalArgumentException("the two ways must share exactly one common node"); // no I18n required + if (!isStartNode(from, via) && ! isEndNode(from, via)) + throw new IllegalArgumentException("via node must be start or end node of from-way"); // no I18n required + if (!isStartNode(to, via) && ! isEndNode(to, via)) + throw new IllegalArgumentException("via node must be start or end node of to-way"); // no I18n required + double phi1 = phi(from, isStartNode(from, via)); + double phi2 = phi(to, isEndNode(to, via)); + return phi1 - phi2; + } + + static public enum RelativeWayJoinOrientation { + LEFT, + RIGHT + } + /** + *Determines the orientation in which two ways {@code from} and {@code to} + * are connected, with respect to the direction of the way {@code from}.
+ * + *The following preconditions must be met: + *
Here's a typical configuration:
+ *+ * to1 to2 + * -------------> o --------------> + * ^ + * | from + * | + *+ * + *
Replies null, if the preconditions aren't met and the method fails to + * determine the join orientation.
+ * + * @param from the "from"-way + * @param to the "to"-way + * @return the join orientation or null, if the method fails to compute the + * join orientation + */ + public static RelativeWayJoinOrientation determineWayJoinOrientation(Way from, Way to){ + Node via = getUniqueCommonNode(from, to); + if (via == null) return null; + if (!isConnectingNode(from, to, 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(from, via)) return null; + if (isClosedAt(to, via)) return null; + + double phi = interesectionAngle(from, to); + if (phi >=0 && phi <= Math.PI) { + return RelativeWayJoinOrientation.RIGHT; + } else { + return RelativeWayJoinOrientation.LEFT; + } + } + + /** + *Selects either of the two ways resulting from the split of a way + * in the role {@link TurnRestrictionLegRole#TO TO}.
+ * + *This methods operates on three ways for which the following + * preconditions must be met: + *
Here's a typical configuration:
+ *+ * to1 to2 + * -------------> o --------------> + * ^ + * | from + * | + *+ * + *
Depending on {@code restrictionType}, this method either returns {@code to1} + * or {@code to2}. If {@code restrictionType} indicates that our context is a + * "left turn", {@code to1} is replied. If our context is a "right turn", {@code to2} + * is returned.
+ * + *Replies null, if the expected preconditions aren't met or if we can't infer + * from {@code restrictionType} whether our context is a "left turn" or a "right turn".
+ * + * @param from the from-way + * @param to1 the first part of the split to-way + * @param to2 the second part of the split to-way + * @param restrictionType the restriction type + * @return either {@code to1}, {@code to2}, or {@code null}. + */ + static public Way selectToWayAfterSplit(Way from, Way to1, Way to2, TurnRestrictionType restrictionType){ + if (restrictionType == null) return null; + Node cn1 = TurnRestrictionBuilder.getUniqueCommonNode(from, to1); + if (cn1 == null) return null; + Node cn2 = TurnRestrictionBuilder.getUniqueCommonNode(from, to2); + if (cn2 == null) return null; + if (cn1 != cn2) return null; + + if (! isStartNode(from, cn1) && ! isEndNode(from, cn1)) { + /* + * the now split to-way still *interesects* the from-way. We + * can't adjust the split decisions. + */ + return null; + } + + RelativeWayJoinOrientation o1 = determineWayJoinOrientation(from, to1); + RelativeWayJoinOrientation o2 = determineWayJoinOrientation(from, to2); + + switch(restrictionType){ + case NO_LEFT_TURN: + case ONLY_LEFT_TURN: + if (RelativeWayJoinOrientation.LEFT.equals(o1)) return to1; + else if (RelativeWayJoinOrientation.LEFT.equals(o2)) return to2; + else return null; + + case NO_RIGHT_TURN: + case ONLY_RIGHT_TURN: + if (RelativeWayJoinOrientation.RIGHT.equals(o1)) return to1; + else if (RelativeWayJoinOrientation.RIGHT.equals(o2)) return to2; + else return null; + + default: + /* + * For restriction types like NO_U_TURN, NO_STRAIGHT_ON, etc. we + * can select a "left" or "right" way after splitting. + */ + return null; + } + } public TurnRestrictionBuilder(){ @@ -74,44 +336,4 @@ /** - * Replies the unique common node of two ways, or null, if either no - * such node or multiple common nodes exist. - * - * @param w1 the first way - * @param w2 the second way - * @return the common node - */ - protected Node getUniqueCommonNode(Way w1, Way w2){ - ListReplies true, if the ways {@code w1} and {@code w2} are connected * at the node {@code n}.
@@ -125,5 +347,5 @@ * @return */ - protected boolean isConnectingNode(Way w1, Way w2, Node n){ + public static boolean isConnectingNode(Way w1, Way w2, Node n){ if (isStartNode(w1, n)) { return isStartNode(w2, n) | isEndNode(w2, n); @@ -141,91 +363,10 @@ * @return true, if the way {@code w} is closed at the node {@code n}. */ - protected boolean isClosedAt(Way w, Node n){ + public static 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(ListCreates the issue for a pair of ways {@code from} and {@code to} which interesect + * at node {@code intersect}.
+ * + * @param parent the parent model + * @param from the way with role "from" + * @param to the way with role "to" + * @param intersect the intersection node + */ + public TurnRestrictionLegSplitRequiredError(IssuesModel parent, Way from, Way to){ + super(parent, Severity.ERROR); + CheckParameterUtil.ensureParameterNotNull(from, "from"); + CheckParameterUtil.ensureParameterNotNull(to, "to"); + + intersect= TurnRestrictionBuilder.getUniqueCommonNode(from, to); + if (intersect == null) + throw new IllegalArgumentException("exactly one intersecting node required"); + + this.from = from; + this.to = to; + this.role = null; + actions.add(new SplitAction()); + } /** @@ -35,5 +66,5 @@ * @param from the way with role 'from' * @param to the way with role 'to' - * @param interesect the node at the intersection + * @param intersect the node at the intersection */ public TurnRestrictionLegSplitRequiredError(IssuesModel parent, TurnRestrictionLegRole role, Way from, Way to, Node intersect) { @@ -42,5 +73,5 @@ this.from = from; this.to = to; - this.interesect = intersect; + this.intersect = intersect; actions.add(new SplitAction()); } @@ -49,20 +80,40 @@ public String getText() { String msg = null; + if (role == null){ + /* + * from and to intersect at a common node. Both have to be split. + */ + return tr("The way {0} with role from and the " + + "way {1} with role to intersect " + + "at node {2}. " + + " "
+ + "Both ways should be split at the intersecting node.",
+ from.getDisplayName(DefaultNameFormatter.getInstance()),
+ to.getDisplayName(DefaultNameFormatter.getInstance()),
+ intersect.getDisplayName(DefaultNameFormatter.getInstance())
+ );
+ }
switch(role){
case FROM:
- msg = tr("The OSM way {0} with role {1} should be split "
+ /*
+ * "to" joins "from" at a common node. Only from has to be split
+ */
+ msg = tr("The way {0} with role {1} should be split "
+ "at node {2} where it connects to way {3}.",
from.getDisplayName(DefaultNameFormatter.getInstance()),
role.getOsmRole(),
- interesect.getDisplayName(DefaultNameFormatter.getInstance()),
+ intersect.getDisplayName(DefaultNameFormatter.getInstance()),
to.getDisplayName(DefaultNameFormatter.getInstance())
);
break;
case TO:
- msg = tr("The OSM way {0} with role {1} should be split "
+ /*
+ * "from" joins "to" at a common node. Only to has to be split
+ */
+ msg = tr("The way {0} with role {1} should be split "
+ "at node {2} where it connects to way {3}.",
to.getDisplayName(DefaultNameFormatter.getInstance()),
role.getOsmRole(),
- interesect.getDisplayName(DefaultNameFormatter.getInstance()),
+ intersect.getDisplayName(DefaultNameFormatter.getInstance()),
from.getDisplayName(DefaultNameFormatter.getInstance())
);
@@ -75,21 +126,55 @@
public SplitAction() {
putValue(NAME, tr("Split now"));
- putValue(SHORT_DESCRIPTION, tr("Splits the way"));
+ putValue(SHORT_DESCRIPTION, tr("Split the ways"));
}
+
public void actionPerformed(ActionEvent e) {
- Way way = null;
- switch(role){
- case FROM: way = from; break;
- case TO: way = to; break;
+
+ SplitWayResult result = null;
+ if (role == null || role.equals(TurnRestrictionLegRole.FROM)){
+ result = SplitWayAction.split(
+ parent.getEditorModel().getLayer(),
+ from,
+ Collections.singletonList(intersect),
+ Collections.