Android-builders-club/OsmAnd
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
OsmAnd/diff_turn_lanes

693 lines
24 KiB
Text
Raw Normal View History

Fix builds
2014-10-03 16:48:49 +02:00
diff --git a/OsmAnd-java/src/net/osmand/router/RouteResultPreparation.java b/OsmAnd-java/src/net/osmand/router/RouteResultPreparation.java
index 1fa0b3a..0ba0981 100644
--- a/OsmAnd-java/src/net/osmand/router/RouteResultPreparation.java
+++ b/OsmAnd-java/src/net/osmand/router/RouteResultPreparation.java
@@ -7,6 +7,7 @@ import java.util.Arrays;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
+import java.util.HashSet;
import org.apache.commons.logging.Log;
@@ -388,6 +389,77 @@ public class RouteResultPreparation {
dist += result.get(i).getDistance();
}
}
+
+ for (int i = result.size() - 2; i >= 0; i--) {
+ RouteSegmentResult currentSegment = result.get(i);
+ RouteSegmentResult nextSegment = result.get(i + 1);
+
+ if (currentSegment.getTurnType() == null || currentSegment.getTurnType().getLanes() == null || nextSegment.getTurnType() == null || nextSegment.getTurnType().getLanes() == null) {
+ continue;
+ }
+
+ // Only allow slight turns to be merged.
+ if (currentSegment.getDistance() < 60 && nextSegment.getTurnType().getLanes().length <= currentSegment.getTurnType().getLanes().length
+ && (currentSegment.getTurnType().getValue() == TurnType.C
+ || currentSegment.getTurnType().getValue() == TurnType.TSLL
+ || currentSegment.getTurnType().getValue() == TurnType.TSLR
+ || currentSegment.getTurnType().getValue() == TurnType.KL
+ || currentSegment.getTurnType().getValue() == TurnType.KR)) {
+ mergeTurnLanes(leftside, currentSegment, nextSegment);
+ }
+ }
+ }
+
private static final int MAX_SPEAK_PRIORITY = 5;
@@ -439,6 +511,7 @@ public class RouteResultPreparation {
} else {
t = TurnType.valueOf(TurnType.TU, leftSide);
}
+ getLanesInfo(prev, t, leftSide);
} else if (mpi < -TURN_DEGREE_MIN) {
if (mpi > -60) {
t = TurnType.valueOf(TurnType.TSLR, leftSide);
@@ -449,6 +522,7 @@ public class RouteResultPreparation {
} else {
t = TurnType.valueOf(TurnType.TU, leftSide);
}
+ getLanesInfo(prev, t, leftSide);
} else {
t = attachKeepLeftInfoAndLanes(leftSide, prev, rr, t);
}
@@ -459,6 +533,82 @@ public class RouteResultPreparation {
return t;
}
private TurnType processRoundaboutTurn(List<RouteSegmentResult> result, int i, boolean leftSide, RouteSegmentResult prev,
RouteSegmentResult rr) {
@@ -491,21 +641,52 @@ public class RouteResultPreparation {
return t;
}
private TurnType attachKeepLeftInfoAndLanes(boolean leftSide, RouteSegmentResult prevSegm, RouteSegmentResult currentSegm, TurnType t) {
// keep left/right
int[] lanes = null;
boolean kl = false;
boolean kr = false;
+ List<OutboundRoad> outboundRoads = new ArrayList<OutboundRoad>();
List<RouteSegmentResult> attachedRoutes = currentSegm.getAttachedRoutes(currentSegm.getStartPointIndex());
- int ls = prevSegm.getObject().getLanes();
- if(ls >= 0 && prevSegm.getObject().getOneway() == 0) {
- ls = (ls + 1) / 2;
- }
- int left = 0;
- int right = 0;
boolean speak = false;
int speakPriority = Math.max(highwaySpeakPriority(prevSegm.getObject().getHighway()), highwaySpeakPriority(currentSegm.getObject().getHighway()));
+ boolean otherRoutesExist = false;
+ boolean rightTurnPossible = false;
+ boolean leftTurnPossible = false;
if (attachedRoutes != null) {
for (RouteSegmentResult attached : attachedRoutes) {
double ex = MapUtils.degreesDiff(attached.getBearingBegin(), currentSegm.getBearingBegin());
@@ -513,73 +694,439 @@ public class RouteResultPreparation {
int rsSpeakPriority = highwaySpeakPriority(attached.getObject().getHighway());
if (rsSpeakPriority != MAX_SPEAK_PRIORITY || speakPriority == MAX_SPEAK_PRIORITY) {
if ((ex < TURN_DEGREE_MIN || mpi < TURN_DEGREE_MIN) && ex >= 0) {
+ // It's ex >= 0 so that turns remaining on the current road are counted as well
kl = true;
int lns = attached.getObject().getLanes();
}
- if (lns > 0) {
- right += lns;
+ if (lns <= 0) {
+ lns = 1;
}
- speak = speak || rsSpeakPriority <= speakPriority;
+ outboundRoads.add(new OutboundRoad(ex, lns, attached));
+ speak |= rsSpeakPriority <= speakPriority;
} else if ((ex > -TURN_DEGREE_MIN || mpi < TURN_DEGREE_MIN) && ex <= 0) {
}
- if (lns > 0) {
- left += lns;
+ if (lns <= 0) {
+ lns = 1;
}
- speak = speak || rsSpeakPriority <= speakPriority;
+ outboundRoads.add(new OutboundRoad(ex, lns, attached));
+ speak |= rsSpeakPriority <= speakPriority;
+ }
+ }
+ if (mpi > TURN_DEGREE_MIN) {
+ otherRoutesExist = true;
+ if (ex > TURN_DEGREE_MIN) {
+ // A right turn is allowed at this intersection.
+ rightTurnPossible = true;
+ } else if (ex < TURN_DEGREE_MIN) {
+ // A left turn is allowed at this intersection.
+ leftTurnPossible = true;
}
}
}
}
- if(kr && left == 0) {
- left = 1;
- } else if(kl && right == 0) {
- right = 1;
- }
+
+ // attachedRoutes covers all allowed outbound routes at that point except currentSegm.
if (current <= 0) {
current = 1;
}
-// if(ls >= 0 /*&& current + left + right >= ls*/){
- lanes = new int[current + left + right];
- ls = current + left + right;
- for(int it=0; it< ls; it++) {
- if(it < left || it >= left + current) {
- lanes[it] = 0;
- } else {
- lanes[it] = 1;
+ outboundRoads.add(new OutboundRoad(0, current, currentSegm));
+
+ Collections.sort(outboundRoads);
+
+ int totalOutboundLanes = 0;
+ for (OutboundRoad road : outboundRoads) {
+ totalOutboundLanes += road.getLanes();
+ }
+
+ lanes = new int[totalOutboundLanes];
+ int i = 0;
+ int left = 0;
+ int right = 0;
+ for (OutboundRoad road : outboundRoads) {
+ for (int j = 0; i < lanes.length && j < road.getLanes(); i++, j++) {
+ lanes[i] = road.getAngle() == 0 ? TurnType.BIT_LANE_ALLOWED : 0;
+ if (road.getAngle() < 0) {
+ left++;
+ } else if (road.getAngle() > 0) {
+ right++;
}
}
- // sometimes links are
- if ((current <= left + right) && (left > 1 || right > 1)) {
- speak = true;
- }
-// }
+ }
+ // sometimes links are
+ if ((current <= left + right) && (left > 1 || right > 1)) {
+ speak = true;
+ }
+
+ double deviation = Math.abs(MapUtils.degreesDiff(prevSegm.getBearingEnd(), currentSegm.getBearingBegin()));
+ boolean makeSlightTurn = deviation > 5 && (!isMotorway(prevSegm) || !isMotorway(currentSegm));
+ if (kl && kr) {
+ t = TurnType.valueOf(TurnType.C, leftSide);
- double devation = Math.abs(MapUtils.degreesDiff(prevSegm.getBearingEnd(), currentSegm.getBearingBegin()));
- boolean makeSlightTurn = devation > 5 && (!isMotorway(prevSegm) || !isMotorway(currentSegm));
- if (kl) {
+ t.setSkipToSpeak(!speak);
+ } else if (kl) {
t = TurnType.valueOf(makeSlightTurn ? TurnType.TSLL : TurnType.KL, leftSide);
t.setSkipToSpeak(!speak);
- }
- if (kr) {
+ } else if (kr) {
t = TurnType.valueOf(makeSlightTurn ? TurnType.TSLR : TurnType.KR, leftSide);
t.setSkipToSpeak(!speak);
+ } else {
+ if (!otherRoutesExist) {
+ return null;
+ }
+ // Most likely, we're going straight at a 90-degree intersection with another road
+ t = TurnType.valueOf(TurnType.C, leftSide);
+ t.setSkipToSpeak(true); // Always skip the talking when going straight
+
+ int prevLanes = prevSegm.getObject().getLanes();
+ if(prevSegm.getObject().getOneway() == 0) {
+ if (prevSegm.isForwardDirection()
+ && prevSegm.getObject().getValue("lanes:forward") != null) {
+ prevLanes = Integer.parseInt(prevSegm.getObject().getValue("lanes:forward"));
+ } else if (!prevSegm.isForwardDirection()
+ && prevSegm.getObject().getValue("lanes:backward") != null) {
+ prevLanes = Integer.parseInt(prevSegm.getObject().getValue("lanes:backward"));
+ } else {
+ prevLanes = (prevLanes + 1) / 2;
+ }
+ }
+ if (prevLanes <= 0) {
+ return null;
+ }
+ lanes = new int[prevLanes];
+
+ String turnLanes;
+ if (prevSegm.getObject().getOneway() == 0) {
+ if (prevSegm.isForwardDirection()) {
+ turnLanes = prevSegm.getObject().getValue("turn:lanes:forward");
+ } else {
+ turnLanes = prevSegm.getObject().getValue("turn:lanes:backward");
+ }
+ } else {
+ turnLanes = prevSegm.getObject().getValue("turn:lanes");
+ }
+
+ if (turnLanes == null) {
+ return null;
+ }
+
+ String[] splitLaneOptions = turnLanes.split("\\|", -1);
+ if (splitLaneOptions.length != lanes.length) {
+ // Error in data or missing data
+ return null;
+ }
+
+ t.setLanes(lanes);
+
+ assignTurns(splitLaneOptions, t);
+
+ // In some cases (at least in the US), the rightmost lane might not have a right turn indicator, but is allowed. This section adds in that indicator. The same applies for where leftSide is true.
+ if (leftSide) {
+ if (leftTurnPossible
+ && !t.isTurnAllowed(0, TurnType.Turn.LEFT)
+ && !t.isTurnAllowed(0, TurnType.Turn.SLIGHT_LEFT)
+ && !t.isTurnAllowed(0, TurnType.Turn.SHARP_LEFT)) {
+ if (t.getPrimaryTurn(0) != TurnType.Turn.UNKNOWN && t.getSecondaryTurn(0) == TurnType.Turn.UNKNOWN) {
+ // This was just to make sure that there's no bad data and that there's an empty slot.
+ t.setSecondaryTurn(0, TurnType.Turn.LEFT);
+ }
+ }
+ } else {
+ if (rightTurnPossible
+ && !t.isTurnAllowed(lanes.length - 1, TurnType.Turn.RIGHT)
+ && !t.isTurnAllowed(lanes.length - 1, TurnType.Turn.SLIGHT_RIGHT)
+ && !t.isTurnAllowed(lanes.length - 1, TurnType.Turn.SHARP_RIGHT)) {
+ if (t.getPrimaryTurn(lanes.length - 1) != TurnType.Turn.UNKNOWN && t.getSecondaryTurn(lanes.length - 1) == TurnType.Turn.UNKNOWN) {
+ // This was just to make sure that there's no bad data and that there's an empty slot.
+ t.setSecondaryTurn(lanes.length - 1, TurnType.Turn.RIGHT);
+ }
+ }
+ }
+
+ // Manually set the allowed lanes, in case the turn gets merged.
+ for (int j = 0; j < lanes.length; j++) {
+ if (t.isTurnAllowed(j, TurnType.Turn.STRAIGHT)) {
+ t.getLanes()[j] |= TurnType.BIT_LANE_ALLOWED;
+ }
+ }
+
+ return t;
}
+
if (t != null && lanes != null) {
t.setLanes(lanes);
+
+ // This code block, in the cases where turn:lanes is not available, replaces the straight arrows with slight-left or slight-right arrows. It compares the number of lanes going straight to the number of lanes turning to determine which symbol to display where.
+ boolean crossedLeftSide = false;
+ for (int j = 0; j < t.getLanes().length; j++) {
+ if (!crossedLeftSide && (t.getLanes()[j] & TurnType.BIT_LANE_ALLOWED) == 0) {
+ if (current > left + right || right != 0) {
+ t.setPrimaryTurn(j, TurnType.Turn.SLIGHT_LEFT);
+ } else {
+ t.setPrimaryTurn(j, TurnType.Turn.STRAIGHT);
+ }
+ } else {
+ crossedLeftSide = true;
+ if ((t.getLanes()[j] & TurnType.BIT_LANE_ALLOWED) == TurnType.BIT_LANE_ALLOWED) {
+ if (current > left + right || (left != 0 && right != 0)) {
+ t.setPrimaryTurn(j, TurnType.Turn.STRAIGHT);
+ } else if (left != 0) {
+ t.setPrimaryTurn(j, TurnType.Turn.SLIGHT_RIGHT);
+ } else if (right != 0) {
+ t.setPrimaryTurn(j, TurnType.Turn.SLIGHT_LEFT);
+ }
+ } else {
+ if (current > left + right || left != 0) {
+ t.setPrimaryTurn(j, TurnType.Turn.SLIGHT_RIGHT);
+ } else {
+ t.setPrimaryTurn(j, TurnType.Turn.STRAIGHT);
+ }
+ }
+ }
+ }
+
+ t = attachTurnLanesData(leftSide, prevSegm, t);
}
+
return t;
}
-
===============================================================================
+ private void mergeTurnLanes(boolean leftSide, RouteSegmentResult currentSegment, RouteSegmentResult nextSegment) {
+ if (currentSegment.getTurnType().isTurnLanesRendering() && nextSegment.getTurnType().isTurnLanesRendering()) {
+ int[] lanes = new int[currentSegment.getTurnType().getLanes().length];
+ for (int i = 0; i < lanes.length; i++) {
+ lanes[i] = currentSegment.getTurnType().getLanes()[i] & ~TurnType.BIT_LANE_ALLOWED;
+ }
+ int matchingIndex = 0;
+ int maxMatchedLanes = 0;
+ for (int i = 0; i < lanes.length; i++) {
+ int matchedLanes = 0;
+ for (int j = 0; j < nextSegment.getTurnType().getLanes().length - i; j++) {
+ if (nextSegment.getTurnType().getPrimaryTurn(j) == currentSegment.getTurnType().getPrimaryTurn(i + j)) {
+ matchedLanes++;
+ } else {
+ break;
+ }
+ }
+ if (matchedLanes > maxMatchedLanes) {
+ matchingIndex = i;
+ maxMatchedLanes = matchedLanes;
+ }
+ }
+ if (maxMatchedLanes <= 1) {
+ return;
+ }
+ for (int i = matchingIndex; i - matchingIndex < nextSegment.getTurnType().getLanes().length; i++) {
+ lanes[i] |= nextSegment.getTurnType().getLanes()[i - matchingIndex] & TurnType.BIT_LANE_ALLOWED;
+ }
+ currentSegment.getTurnType().setLanes(lanes);
+ currentSegment.setTurnType(inferTurnFromLanes(currentSegment.getTurnType(), leftSide));
+ } else if (!currentSegment.getTurnType().isTurnLanesRendering() && !nextSegment.getTurnType().isTurnLanesRendering()) {
+ int[] lanes = new int[currentSegment.getTurnType().getLanes().length];
+ int matchingIndex = 0;
+ int expectedLanes = 0;
+ for (int i = 0; i < lanes.length; i++) {
+ lanes[i] = currentSegment.getTurnType().getLanes()[i] & ~TurnType.BIT_LANE_ALLOWED;
+ if (currentSegment.getTurnType().getPrimaryTurn(i) == TurnType.Turn.SLIGHT_LEFT) {
+ matchingIndex++;
+ } else if (currentSegment.getTurnType().getPrimaryTurn(i) == TurnType.Turn.STRAIGHT) {
+ expectedLanes++;
+ }
+ }
+ if (nextSegment.getTurnType().getLanes().length != expectedLanes) {
+ return;
+ }
+ for (int i = matchingIndex; i - matchingIndex < nextSegment.getTurnType().getLanes().length; i++) {
+ lanes[i] = nextSegment.getTurnType().getLanes()[i - matchingIndex];
+ }
+ currentSegment.getTurnType().setLanes(lanes);
+ }
}
+ private class OutboundRoad implements Comparable<OutboundRoad>{
+ private final double angle;
+ private final int lanes;
+ private final RouteSegmentResult road;
+
+ public OutboundRoad(double angle, int lanes, RouteSegmentResult road) {
+ this.angle = angle;
+ this.lanes = lanes;
+ this.road = road;
+ }
+
+ public double getAngle() {
+ return angle;
+ }
+
+ public int getLanes() {
+ return lanes;
+ }
+
+ public RouteSegmentResult getRoad() {
+ return road;
+ }
+
+ public int compareTo(OutboundRoad other) {
+ if (other.angle - this.angle < 0) {
+ return 1;
+ } else if (other.angle - this.angle > 0) {
+ return -1;
+ } else {
+ return 0;
+ }
+ }
+ }
+ private void getLanesInfo(RouteSegmentResult prevSegm, TurnType t, boolean leftSide) {
+ int lanes = prevSegm.getObject().getLanes();
+ if(prevSegm.getObject().getOneway() == 0) {
+ if (prevSegm.isForwardDirection()
+ && prevSegm.getObject().getValue("lanes:forward") != null) {
+ lanes = Integer.parseInt(prevSegm.getObject().getValue("lanes:forward"));
+ } else if (!prevSegm.isForwardDirection()
+ && prevSegm.getObject().getValue("lanes:backward") != null) {
+ lanes = Integer.parseInt(prevSegm.getObject().getValue("lanes:backward"));
+ } else {
+ lanes = (lanes + 1) / 2;
+ }
+ }
+ if (lanes <= 0) {
+ return;
+ }
+
+ String turnLanes;
+ if (prevSegm.getObject().getOneway() == 0) {
+ if (prevSegm.isForwardDirection()) {
+ turnLanes = prevSegm.getObject().getValue("turn:lanes:forward");
+ } else {
+ turnLanes = prevSegm.getObject().getValue("turn:lanes:backward");
+ }
+ } else {
+ turnLanes = prevSegm.getObject().getValue("turn:lanes");
+ }
+
+ if (turnLanes == null) {
+ return;
+ }
+
+ String[] splitLaneOptions = turnLanes.split("\\|", -1);
+ if (splitLaneOptions.length != lanes) {
+ // Error in data or missing data, go to old behavior
+ return;
+ }
+
+ int[] lanesArray = new int[lanes];
+
+ t.setLanes(lanesArray);
+
+ assignTurns(splitLaneOptions, t);
+
+ // In some cases (at least in the US), the rightmost lane might not have a right turn indicator, but is allowed. This section adds in that indicator. The same applies for where leftSide is true.
+ if (leftSide) {
+ if (t.getValue() == TurnType.TL
+ && !t.isTurnAllowed(0, TurnType.Turn.LEFT)
+ && !t.isTurnAllowed(0, TurnType.Turn.SLIGHT_LEFT)
+ && !t.isTurnAllowed(0, TurnType.Turn.SHARP_LEFT)) {
+ if (t.getPrimaryTurn(0) != TurnType.Turn.UNKNOWN && t.getSecondaryTurn(0) == TurnType.Turn.UNKNOWN) {
+ // This was just to make sure that there's no bad data and that there's an empty slot.
+ t.setSecondaryTurn(0, TurnType.Turn.LEFT);
+ lanesArray[0] |= TurnType.BIT_LANE_ALLOWED;
+ }
+ }
+ } else {
+ if (t.getValue() == TurnType.TR
+ && !t.isTurnAllowed(lanesArray.length - 1, TurnType.Turn.RIGHT)
+ && !t.isTurnAllowed(lanesArray.length - 1, TurnType.Turn.SLIGHT_RIGHT)
+ && !t.isTurnAllowed(lanesArray.length - 1, TurnType.Turn.SHARP_RIGHT)) {
+ if (t.getPrimaryTurn(lanesArray.length - 1) != TurnType.Turn.UNKNOWN && t.getSecondaryTurn(lanesArray.length - 1) == TurnType.Turn.UNKNOWN) {
+ // This was just to make sure that there's no bad data and that there's an empty slot.
+ t.setSecondaryTurn(lanesArray.length - 1, TurnType.Turn.RIGHT);
+ lanesArray[lanesArray.length - 1] |= TurnType.BIT_LANE_ALLOWED;
+ }
+ }
+ }
+
+ // Manually set the allowed lanes.
+ for (int i = 0; i < lanesArray.length; i++) {
+ if (t.getPrimaryTurn(i).getValue() == t.getValue() || t.getSecondaryTurn(i).getValue() == t.getValue()) {
+ lanesArray[i] |= TurnType.BIT_LANE_ALLOWED;
+ }
+ }
+ }
+
+ private TurnType attachTurnLanesData(boolean leftSide, RouteSegmentResult prevSegm, TurnType t) {
+ int lanes = prevSegm.getObject().getLanes();
+ String turnLanes;
+ if (prevSegm.getObject().getOneway() == 0) {
+ if (prevSegm.isForwardDirection()) {
+ turnLanes = prevSegm.getObject().getValue("turn:lanes:forward");
+ } else {
+ turnLanes = prevSegm.getObject().getValue("turn:lanes:backward");
+ }
+ } else {
+ turnLanes = prevSegm.getObject().getValue("turn:lanes");
+ }
+
+ if (turnLanes == null) {
+ return t;
+ }
+
+ String[] splitLaneOptions = turnLanes.split("\\|", -1);
+ if (splitLaneOptions.length != lanes) {
+ // Error in data or missing data, go to old behavior
+ return t;
+ }
+
+ if (t.getLanes().length != lanes) {
+ // The turn:lanes don't easily match up to the target road.
+
+ List<Integer> sourceLanes = new ArrayList<Integer>();
+
+ int outgoingLanesIndex = 0;
+ int sourceLanesIndex = 0;
+
+ while (outgoingLanesIndex < t.getLanes().length && sourceLanesIndex < lanes) {
+ if (splitLaneOptions[sourceLanesIndex].contains(";")) {
+ int options = countOccurrences(splitLaneOptions[sourceLanesIndex], ';');
+ if (options == 1) {
+ if (outgoingLanesIndex + 1 >= t.getLanes().length) {
+ // Likely an error in data
+ return t;
+ }
+ int usability = t.getLanes()[outgoingLanesIndex] | t.getLanes()[outgoingLanesIndex + 1];
+ sourceLanes.add(usability);
+ outgoingLanesIndex += 2;
+ sourceLanesIndex++;
+ } else {
+ // Not supported
+ return t;
+ }
+ } else {
+ sourceLanes.add(t.getLanes()[outgoingLanesIndex]);
+ outgoingLanesIndex++;
+ sourceLanesIndex++;
+ }
+ }
+
+ int[] newLanes = new int[sourceLanes.size()];
+
+ for (int i = 0; i < sourceLanes.size(); i++) {
+ newLanes[i] = sourceLanes.get(i);
+ }
+
+ t.setLanes(newLanes);
+ }
+
+ assignTurns(splitLaneOptions, t);
+
+ t = inferTurnFromLanes(t, leftSide);
+
+ return t;
+ }
+
+ private void assignTurns(String[] splitLaneOptions, TurnType t) {
+ for (int i = 0; i < splitLaneOptions.length; i++) {
+ String[] laneOptions = splitLaneOptions[i].split(";");
+
+ boolean primaryTurnSet = false;
+
+ for (int j = 0; j < laneOptions.length; j++) {
+ if (laneOptions[j].equals("none") || laneOptions[j].equals("through")) {
+ TurnType.Turn turn = TurnType.Turn.STRAIGHT;
+ if (!primaryTurnSet) {
+ t.setPrimaryTurn(i, turn);
+ primaryTurnSet = true;
+ } else {
+ t.setSecondaryTurn(i, turn);
+ continue;
+ }
+ } else if (laneOptions[j].equals("slight_right")) {
+ TurnType.Turn turn = TurnType.Turn.SLIGHT_RIGHT;
+ if (!primaryTurnSet) {
+ t.setPrimaryTurn(i, turn);
+ primaryTurnSet = true;
+ } else {
+ t.setSecondaryTurn(i, turn);
+ continue;
+ }
+ } else if (laneOptions[j].equals("slight_left")) {
+ TurnType.Turn turn = TurnType.Turn.SLIGHT_LEFT;
+ if (!primaryTurnSet) {
+ t.setPrimaryTurn(i, turn);
+ primaryTurnSet = true;
+ } else {
+ t.setSecondaryTurn(i, turn);
+ continue;
+ }
+ } else if (laneOptions[j].equals("right")) {
+ TurnType.Turn turn = TurnType.Turn.RIGHT;
+ if (!primaryTurnSet) {
+ t.setPrimaryTurn(i, turn);
+ primaryTurnSet = true;
+ } else {
+ t.setSecondaryTurn(i, turn);
+ continue;
+ }
+ } else if (laneOptions[j].equals("left")) {
+ TurnType.Turn turn = TurnType.Turn.LEFT;
+ if (!primaryTurnSet) {
+ t.setPrimaryTurn(i, turn);
+ primaryTurnSet = true;
+ } else {
+ t.setSecondaryTurn(i, turn);
+ continue;
+ }
+ } else if (laneOptions[j].equals("sharp_right")) {
+ TurnType.Turn turn = TurnType.Turn.SHARP_RIGHT;
+ if (!primaryTurnSet) {
+ t.setPrimaryTurn(i, turn);
+ primaryTurnSet = true;
+ } else {
+ t.setSecondaryTurn(i, turn);
+ continue;
+ }
+ } else if (laneOptions[j].equals("sharp_left")) {
+ TurnType.Turn turn = TurnType.Turn.SHARP_LEFT;
+ if (!primaryTurnSet) {
+ t.setPrimaryTurn(i, turn);
+ primaryTurnSet = true;
+ } else {
+ t.setSecondaryTurn(i, turn);
+ continue;
+ }
+ } else if (laneOptions[j].equals("reverse")) {
+ TurnType.Turn turn = TurnType.Turn.UTURN;
+ if (!primaryTurnSet) {
+ t.setPrimaryTurn(i, turn);
+ primaryTurnSet = true;
+ } else {
+ t.setSecondaryTurn(i, turn);
+ continue;
+ }
+ }
+ }
+ }
+
+ t.setTurnLanesRendering(true);
+ }
+
+ private TurnType inferTurnFromLanes(TurnType t, boolean leftSide) {
+ List<TurnType.Turn> possibleTurns = new ArrayList<TurnType.Turn>();
+ boolean filled = false;
+ for (int i = 0; i < t.getLanes().length; i++) {
+ if ((t.getLanes()[i] & TurnType.BIT_LANE_ALLOWED) == TurnType.BIT_LANE_ALLOWED) {
+ if (!filled) {
+ filled = true;
+ possibleTurns.add(t.getPrimaryTurn(i));
+ if (t.getSecondaryTurn(i) != TurnType.Turn.UNKNOWN) {
+ possibleTurns.add(t.getSecondaryTurn(i));
+ }
+ } else {
+ List<TurnType.Turn> laneTurns = new ArrayList<TurnType.Turn>();
+ laneTurns.add(t.getPrimaryTurn(i));
+ laneTurns.add(t.getSecondaryTurn(i));
+ possibleTurns.retainAll(laneTurns);
+ }
+ }
+ }
+
+ if (possibleTurns.size() > 1) {
+ for (int i = 0; i < t.getLanes().length; i++) {
+ if ((t.getLanes()[i] & TurnType.BIT_LANE_ALLOWED) == 0 && !possibleTurns.isEmpty()) {
+ List<TurnType.Turn> notLaneTurns = new ArrayList<TurnType.Turn>();
+ notLaneTurns.add(t.getPrimaryTurn(i));
+ notLaneTurns.add(t.getSecondaryTurn(i));
+ possibleTurns.removeAll(notLaneTurns);
+ }
+ }
+ }
+
+ // removing duplicates
+ if (new HashSet<TurnType.Turn>(possibleTurns).size() == 1) {
+ TurnType derivedTurnType = TurnType.valueOf(possibleTurns.get(0).getValue(), false);
+ derivedTurnType.setLanes(t.getLanes());
+ derivedTurnType.setSkipToSpeak(t.isSkipToSpeak());
+ derivedTurnType.setTurnLanesRendering(t.isTurnLanesRendering());
+ t = derivedTurnType;
+ }
+
+ return t;
+ }
+
+ private int countOccurrences(String haystack, char needle) {
+ int count = 0;
+ for (int i = 0; i < haystack.length(); i++) {
+ if (haystack.charAt(i) == needle) {
+ count++;
+ }
+ }
+ return count;
+ }
+
Reference in a new issue Copy permalink