Index: src/uk/me/parabola/imgfmt/app/Coord.java =================================================================== --- src/uk/me/parabola/imgfmt/app/Coord.java (revision 3631) +++ src/uk/me/parabola/imgfmt/app/Coord.java (working copy) @@ -49,6 +49,7 @@ private final static short PART_OF_SHAPE2 = 0x0100; // use only in ShapeMerger private final static short END_OF_WAY = 0x0200; // use only in WrongAngleFixer private final static short HOUSENUMBER_NODE = 0x0400; // start/end of house number interval + private final static short ADDED_HOUSENUMBER_NODE = 0x0800; // node was added for house numbers public final static int HIGH_PREC_BITS = 30; public final static int DELTA_SHIFT = 6; @@ -88,7 +89,7 @@ int lon30 = toBit30(longitude); this.latDelta = (byte) ((this.latitude << 6) - lat30); this.lonDelta = (byte) ((this.longitude << 6) - lon30); - + // verify math assert (this.latitude << 6) - latDelta == lat30; assert (this.longitude << 6) - lonDelta == lon30; @@ -340,7 +341,6 @@ } /** - * Set or unset flag for {@link WrongAngleFixer} * @param b true or false */ public void setNumberNode(boolean b) { @@ -350,6 +350,23 @@ this.flags &= ~HOUSENUMBER_NODE; } + /** + * @return if this is the beginning/end of a house number interval + */ + public boolean isAddedNumberNode(){ + return (flags & ADDED_HOUSENUMBER_NODE) != 0; + } + + /** + * @param b true or false + */ + public void setAddedNumberNode(boolean b) { + if (b) + this.flags |= ADDED_HOUSENUMBER_NODE; + else + this.flags &= ~ADDED_HOUSENUMBER_NODE; + } + public int hashCode() { // Use a factor for latitude to span over the whole integer range: // max lat: 4194304 Index: src/uk/me/parabola/imgfmt/app/net/RoadNetwork.java =================================================================== --- src/uk/me/parabola/imgfmt/app/net/RoadNetwork.java (revision 3631) +++ src/uk/me/parabola/imgfmt/app/net/RoadNetwork.java (working copy) @@ -49,7 +49,8 @@ private final List boundary = new ArrayList<>(); private final List roadDefs = new ArrayList<>(); private List centers = new ArrayList<>(); - private int adjustTurnHeadings ; + private AngleChecker angleChecker = new AngleChecker(); + private boolean checkRoundabouts; private boolean checkRoundaboutFlares; private int maxFlareLengthRatio ; @@ -56,18 +57,11 @@ private boolean reportSimilarArcs; public void config(EnhancedProperties props) { - String ath = props.getProperty("adjust-turn-headings"); - if(ath != null) { - if(ath.length() > 0) - adjustTurnHeadings = Integer.decode(ath); - else - adjustTurnHeadings = RouteNode.ATH_DEFAULT_MASK; - } checkRoundabouts = props.getProperty("check-roundabouts", false); checkRoundaboutFlares = props.getProperty("check-roundabout-flares", false); maxFlareLengthRatio = props.getProperty("max-flare-length-ratio", 0); - reportSimilarArcs = props.getProperty("report-similar-arcs", false); + angleChecker.config(props); } public void addRoad(RoadDef roadDef, List coordList) { @@ -128,7 +122,6 @@ RouteNode node1 = getOrAddNode(lastId, lastCoord); RouteNode node2 = getOrAddNode(id, co); - if(node1 == node2) log.error("Road " + roadDef + " contains consecutive identical nodes at " + co.toOSMURL() + " - routing will be broken"); else if(arcLength == 0) @@ -135,25 +128,27 @@ log.warn("Road " + roadDef + " contains zero length arc at " + co.toOSMURL()); Coord forwardBearingPoint = coordList.get(lastIndex + 1); - if(lastCoord.equals(forwardBearingPoint)) { + if(lastCoord.equals(forwardBearingPoint) || forwardBearingPoint.isAddedNumberNode()) { // bearing point is too close to last node to be // useful - try some more points for(int bi = lastIndex + 2; bi <= index; ++bi) { - if(!lastCoord.equals(coordList.get(bi))) { - forwardBearingPoint = coordList.get(bi); - break; - } + Coord coTest = coordList.get(bi); + if (coTest.isAddedNumberNode() || lastCoord.equals(coTest)) + continue; + forwardBearingPoint = coTest; + break; } } Coord reverseBearingPoint = coordList.get(index - 1); - if(co.equals(reverseBearingPoint)) { + if(co.equals(reverseBearingPoint) || reverseBearingPoint.isAddedNumberNode()) { // bearing point is too close to this node to be // useful - try some more points for(int bi = index - 2; bi >= lastIndex; --bi) { - if(!co.equals(coordList.get(bi))) { - reverseBearingPoint = coordList.get(bi); - break; - } + Coord coTest = coordList.get(bi); + if (coTest.isAddedNumberNode() || co.equals(coTest)) + continue; + reverseBearingPoint = coTest; + break; } } @@ -162,24 +157,16 @@ double reverseInitialBearing = co.bearingTo(reverseBearingPoint); double directLength = (lastIndex + 1 == index) ? arcLength : lastCoord.distance(co); - double reverseFinalBearing, forwardFinalBearing, reverseDirectBearing; + double reverseDirectBearing = 0; if (directLength > 0){ // bearing on rhumb line is a constant, so we can simply revert reverseDirectBearing = (forwardDirectBearing <= 0) ? 180 + forwardDirectBearing: -(180 - forwardDirectBearing) % 180.0; - forwardFinalBearing = (reverseInitialBearing <= 0) ? 180 + reverseInitialBearing : -(180 - reverseInitialBearing) % 180.0; - reverseFinalBearing = (forwardInitialBearing <= 0) ? 180 + forwardInitialBearing : -(180 - forwardInitialBearing) % 180.0; } - else { - reverseDirectBearing = 0; - forwardFinalBearing = 0; - reverseFinalBearing = 0; - } // Create forward arc from node1 to node2 RouteArc arc = new RouteArc(roadDef, node1, node2, forwardInitialBearing, - forwardFinalBearing, forwardDirectBearing, arcLength, arcLength, @@ -192,7 +179,6 @@ RouteArc reverseArc = new RouteArc(roadDef, node2, node1, reverseInitialBearing, - reverseFinalBearing, reverseDirectBearing, arcLength, arcLength, @@ -269,8 +255,7 @@ if(reportSimilarArcs) node.reportSimilarArcs(); } - if(adjustTurnHeadings != 0) - node.tweezeArcs(adjustTurnHeadings); + nod1.addNode(node); n++; } @@ -281,6 +266,7 @@ public List getCenters() { if (centers.isEmpty()){ + angleChecker.check(nodes); addArcsToMajorRoads(); splitCenters(); } Index: src/uk/me/parabola/imgfmt/app/net/RouteArc.java =================================================================== --- src/uk/me/parabola/imgfmt/app/net/RouteArc.java (revision 3631) +++ src/uk/me/parabola/imgfmt/app/net/RouteArc.java (working copy) @@ -43,7 +43,6 @@ // heading / bearing: private float initialHeading; // degrees (A-> B in an arc ABCD) - private final float finalHeading; // degrees (C-> D in an arc ABCD) private final float directHeading; // degrees (A-> D in an arc ABCD) private final RoadDef roadDef; @@ -81,7 +80,6 @@ * @param source The source node. (A) * @param dest The destination node (E). * @param initialBearing The initial heading (signed degrees) (A->B) - * @param finalBearing The final heading (signed degrees) (D->E) * @param directBearing The direct heading (signed degrees) (A->E) * @param arcLength the length of the arc in meter (A->B->C->D->E) * @param pathLength the length of the arc in meter (summed length for additional arcs) @@ -90,7 +88,7 @@ */ public RouteArc(RoadDef roadDef, RouteNode source, RouteNode dest, - double initialBearing, double finalBearing, double directBearing, + double initialBearing, double directBearing, double arcLength, double pathLength, double directLength, @@ -100,7 +98,6 @@ this.source = source; this.dest = dest; this.initialHeading = (float) initialBearing; - this.finalHeading = (float) finalBearing; this.directHeading = (directBearing < 180) ? (float) directBearing : -180.0f; int len = NODHeader.metersToRaw(arcLength); if (len >= (1 << 22)) { @@ -129,12 +126,21 @@ return initialHeading; } + public float getDirectHeading() { + return directHeading; + } + public void setInitialHeading(float ih) { initialHeading = ih; } public float getFinalHeading() { - return finalHeading; + float fh = 0; + if (lengthInMeter != 0){ + fh = getReverseArc().getInitialHeading(); + fh = (fh <= 0) ? 180.0f + fh : -(180.0f - fh) % 180.0f; + } + return fh; } public RouteNode getSource() { Index: src/uk/me/parabola/imgfmt/app/net/RouteNode.java =================================================================== --- src/uk/me/parabola/imgfmt/app/net/RouteNode.java (revision 3631) +++ src/uk/me/parabola/imgfmt/app/net/RouteNode.java (working copy) @@ -17,7 +17,6 @@ import it.unimi.dsi.fastutil.ints.IntArrayList; import java.util.ArrayList; import java.util.Collections; -import java.util.Comparator; import java.util.HashSet; import java.util.Iterator; import java.util.List; @@ -24,7 +23,6 @@ import uk.me.parabola.imgfmt.app.Coord; import uk.me.parabola.imgfmt.app.CoordNode; import uk.me.parabola.imgfmt.app.ImgFileWriter; -import uk.me.parabola.imgfmt.app.Label; import uk.me.parabola.log.Logger; /** @@ -53,10 +51,6 @@ // only used internally in mkgmap private static final int F_DISCARDED = 0x100; // node has been discarded - private static final int MAX_MAIN_ROAD_HEADING_CHANGE = 120; - private static final int MIN_DIFF_BETWEEN_OUTGOING_AND_OTHER_ARCS = 45; - private static final int MIN_DIFF_BETWEEN_INCOMING_AND_OTHER_ARCS = 50; - private int offsetNod1 = -1; // arcs from this node @@ -352,310 +346,6 @@ return coord.compareTo(otherNode.getCoord()); } - private static boolean possiblySameRoad(RouteArc raa, RouteArc rab) { - - RoadDef rda = raa.getRoadDef(); - RoadDef rdb = rab.getRoadDef(); - - if(rda.getId() == rdb.getId()) { - // roads have the same (OSM) id - return true; - } - - boolean bothArcsNamed = false; - for(Label laba : rda.getLabels()) { - if(laba != null && laba.getOffset() != 0) { - for(Label labb : rdb.getLabels()) { - if(labb != null && labb.getOffset() != 0) { - bothArcsNamed = true; - if(laba.equals(labb)) { - // the roads have the same label - if(rda.isLinkRoad() == rdb.isLinkRoad()) { - // if both are a link road or both are - // not a link road, consider them the - // same road - return true; - } - // One is a link road and the other isn't - // so consider them different roads - this - // is because people often give a link - // road that's leaving some road the same - // ref as that road but it suits us better - // to consider them as different roads - return false; - } - } - } - } - } - - if(bothArcsNamed) { - // both roads have names and they don't match - return false; - } - - // at least one road is unnamed - if(rda.isRoundabout() && rdb.isRoundabout()) { - // hopefully, segments of the same (unnamed) roundabout - return true; - } - - return false; - } - - private static boolean rightTurnRequired(float inHeading, float outHeading, float otherHeading) { - // given the headings of the incoming, outgoing and side - // roads, decide whether a side road is to the left or the - // right of the main road - - outHeading -= inHeading; - while(outHeading < -180) - outHeading += 360; - while(outHeading > 180) - outHeading -= 360; - - otherHeading -= inHeading; - while(otherHeading < -180) - otherHeading += 360; - while(otherHeading > 180) - otherHeading -= 360; - - return otherHeading > outHeading; - } - - private static final int ATH_OUTGOING = 1; - private static final int ATH_INCOMING = 2; - - public static final int ATH_DEFAULT_MASK = ATH_OUTGOING | ATH_INCOMING; - - public void tweezeArcs(int mask) { - if(arcs.size() >= 3) { - - // detect the "shallow turn" scenario where at a junction - // on some "main" road, the side road leaves the main - // road at a very shallow angle and the GPS says "keep - // right/left" when it would be better if it said "turn - // right/left" - - // also helps to produce a turn instruction when the main - // road bends sharply but the side road keeps close to the - // original heading - - // the code tries to detect a pair of arcs (the "incoming" - // arc and the "outgoing" arc) that are the "main road" - // and the remaining arc (called the "other" arc) which is - // the "side road" - - // having worked out the roles for the arcs, the heuristic - // applied is that if the main road doesn't change its - // heading by more than maxMainRoadHeadingChange, ensure - // that the side road heading differs from the outgoing - // heading by at least - // minDiffBetweenOutgoingAndOtherArcs and the side road - // heading differs from the incoming heading by at least - // minDiffBetweenIncomingAndOtherArcs - - // list of outgoing arcs discovered at this node - List outgoingArcs = new ArrayList(); - - // sort incoming arcs by decreasing class/speed - List inArcs = new ArrayList(); - for (RouteArc arc : arcs){ - if (arc.isDirect()) - inArcs.add(arc.getReverseArc()); - } - - Collections.sort(inArcs, new Comparator() { - public int compare(RouteArc ra1, RouteArc ra2) { - int c1 = ra1.getRoadDef().getRoadClass(); - int c2 = ra2.getRoadDef().getRoadClass(); - if(c1 == c2) - return (ra2.getRoadDef().getRoadSpeed() - - ra1.getRoadDef().getRoadSpeed()); - return c2 - c1; - } - }); - - // look at incoming arcs in order of decreasing class/speed - for(RouteArc inArc : inArcs) { - - RoadDef inRoadDef = inArc.getRoadDef(); - - if(!inArc.isForward() && inRoadDef.isOneway()) { - // ignore reverse arc if road is oneway - continue; - } - - float inHeading = inArc.getFinalHeading(); - // determine the outgoing arc that is likely to be the - // same road as the incoming arc - RouteArc outArc = null; - - if(throughRoutes != null) { - // through_route relations have the highest precedence - for(RouteArc[] pair : throughRoutes) { - if(pair[0] == inArc) { - outArc = pair[1]; - log.info("Found through route from " + inRoadDef + " to " + outArc.getRoadDef()); - break; - } - } - } - - if(outArc == null) { - // next, if oa has the same RoadDef as inArc, it's - // definitely the same road - for(RouteArc oa : arcs) { - if (oa.isDirect() == false) - continue; - if(oa.getDest() != inArc.getSource()) { - // this arc is not going to the same node as - // inArc came from - if(oa.getRoadDef() == inRoadDef) { - outArc = oa; - break; - } - } - } - } - - if(outArc == null) { - // next, although the RoadDefs don't match, use - // possiblySameRoad() to see if the roads' id or - // labels (names/refs) match - for(RouteArc oa : arcs) { - if (oa.isDirect() == false) - continue; - if(oa.getDest() != inArc.getSource()) { - // this arc is not going to the same node as - // inArc came from - if((oa.isForward() || !oa.getRoadDef().isOneway()) && - possiblySameRoad(inArc, oa)) { - outArc = oa; - break; - } - } - } - } - - // if we did not find the outgoing arc, give up with - // this incoming arc - if(outArc == null) { - //log.info("Can't continue road " + inRoadDef + " at " + coord.toOSMURL()); - continue; - } - - // remember that this arc is an outgoing arc - outgoingArcs.add(outArc); - - float outHeading = outArc.getInitialHeading(); - float mainHeadingDelta = outHeading - inHeading; - while(mainHeadingDelta > 180) - mainHeadingDelta -= 360; - while(mainHeadingDelta < -180) - mainHeadingDelta += 360; - //log.info(inRoadDef + " continues to " + outArc.getRoadDef() + " with a heading change of " + mainHeadingDelta + " at " + coord.toOSMURL()); - - if(Math.abs(mainHeadingDelta) > MAX_MAIN_ROAD_HEADING_CHANGE) { - // if the continuation road heading change is - // greater than maxMainRoadHeadingChange don't - // adjust anything - continue; - } - - for(RouteArc otherArc : arcs) { - if (otherArc.isDirect() == false) - continue; - - // for each other arc leaving this node, tweeze - // its heading if its heading change from the - // outgoing heading is less than - // minDiffBetweenOutgoingAndOtherArcs or its - // heading change from the incoming heading is - // less than minDiffBetweenIncomingAndOtherArcs - - if(otherArc.getDest() == inArc.getSource() || - otherArc == outArc) { - // we're looking at the incoming or outgoing - // arc, ignore it - continue; - } - - if(!otherArc.isForward() && - otherArc.getRoadDef().isOneway()) { - // ignore reverse arc if road is oneway - continue; - } - - if(inRoadDef.isLinkRoad() && - otherArc.getRoadDef().isLinkRoad()) { - // it's a link road leaving a link road so - // leave the angle unchanged to avoid - // introducing a time penalty by increasing - // the angle (this stops the router using link - // roads that "cut the corner" at roundabouts) - continue; - } - - if(outgoingArcs.contains(otherArc)) { - // this arc was previously matched as an - // outgoing arc so we don't want to change its - // heading now - continue; - } - - float otherHeading = otherArc.getInitialHeading(); - float outToOtherDelta = otherHeading - outHeading; - while(outToOtherDelta > 180) - outToOtherDelta -= 360; - while(outToOtherDelta < -180) - outToOtherDelta += 360; - float inToOtherDelta = otherHeading - inHeading; - while(inToOtherDelta > 180) - inToOtherDelta -= 360; - while(inToOtherDelta < -180) - inToOtherDelta += 360; - - float newHeading = otherHeading; - if(rightTurnRequired(inHeading, outHeading, otherHeading)) { - // side road to the right - if((mask & ATH_OUTGOING) != 0 && - Math.abs(outToOtherDelta) < MIN_DIFF_BETWEEN_OUTGOING_AND_OTHER_ARCS) - newHeading = outHeading + MIN_DIFF_BETWEEN_OUTGOING_AND_OTHER_ARCS; - if((mask & ATH_INCOMING) != 0 && - Math.abs(inToOtherDelta) < MIN_DIFF_BETWEEN_INCOMING_AND_OTHER_ARCS) { - float nh = inHeading + MIN_DIFF_BETWEEN_INCOMING_AND_OTHER_ARCS; - if(nh > newHeading) - newHeading = nh; - } - - if(newHeading > 180) - newHeading -= 360; - } - else { - // side road to the left - if((mask & ATH_OUTGOING) != 0 && - Math.abs(outToOtherDelta) < MIN_DIFF_BETWEEN_OUTGOING_AND_OTHER_ARCS) - newHeading = outHeading - MIN_DIFF_BETWEEN_OUTGOING_AND_OTHER_ARCS; - if((mask & ATH_INCOMING) != 0 && - Math.abs(inToOtherDelta) < MIN_DIFF_BETWEEN_INCOMING_AND_OTHER_ARCS) { - float nh = inHeading - MIN_DIFF_BETWEEN_INCOMING_AND_OTHER_ARCS; - if(nh < newHeading) - newHeading = nh; - } - - if(newHeading < -180) - newHeading += 360; - } - if(Math.abs(newHeading - otherHeading) > 0.0000001) { - otherArc.setInitialHeading(newHeading); - log.info("Adjusting turn heading from " + otherHeading + " to " + newHeading + " at junction of " + inRoadDef + " and " + otherArc.getRoadDef() + " at " + coord.toOSMURL()); - } - } - } - } - } - public void checkRoundabouts() { List roundaboutArcs = new ArrayList(); @@ -1010,7 +700,6 @@ sourceNode, destNode, roadArcs.get(i).getInitialHeading(), // not used - arcToDest.getFinalHeading(), // not used c1.bearingTo(c2), partialArcLength, // from stepNode to destNode on road pathLength, // from sourceNode to destNode on road @@ -1111,4 +800,16 @@ public int hashCode(){ return getCoord().getId(); } + + public List getDirectArcsBetween(RouteNode otherNode) { + List result = new ArrayList<>(); + for(RouteArc a : arcs){ + if(a.isDirect() && a.getDest() == otherNode){ + result.add(a); + } + } + return result; + } + + } Index: src/uk/me/parabola/imgfmt/app/net/RouteRestriction.java =================================================================== --- src/uk/me/parabola/imgfmt/app/net/RouteRestriction.java (revision 3631) +++ src/uk/me/parabola/imgfmt/app/net/RouteRestriction.java (working copy) @@ -63,6 +63,8 @@ private final byte exceptMask; private final byte flags; // meaning of bits 0x01 and 0x10 are not clear + private byte mkgmapExceptMask; + private final static byte F_EXCEPT_FOOT = 0x02; private final static byte F_EXCEPT_EMERGENCY = 0x04; private final static byte F_MORE_EXCEPTIONS = 0x08; @@ -82,6 +84,7 @@ */ public RouteRestriction(RouteNode viaNode, List traffArcs, byte mkgmapExceptMask) { this.viaNode = viaNode; + this.mkgmapExceptMask = mkgmapExceptMask; this.arcs = new ArrayList<>(traffArcs); for (int i = 0; i < arcs.size(); i++){ RouteArc arc = arcs.get(i); @@ -231,4 +234,8 @@ public void setLast() { last = true; } + + public byte getMkgmapExeptMask(){ + return mkgmapExceptMask; + } } Index: src/uk/me/parabola/mkgmap/osmstyle/housenumber/ExtNumbers.java =================================================================== --- src/uk/me/parabola/mkgmap/osmstyle/housenumber/ExtNumbers.java (revision 3631) +++ src/uk/me/parabola/mkgmap/osmstyle/housenumber/ExtNumbers.java (working copy) @@ -1070,6 +1070,7 @@ */ private int addAsNumberNode(int pos, Coord toAdd){ toAdd.setNumberNode(true); + toAdd.setAddedNumberNode(true); getRoad().getPoints().add(pos, toAdd); ExtNumbers work = next; Index: src/uk/me/parabola/mkgmap/osmstyle/housenumber/HousenumberGroup.java =================================================================== --- src/uk/me/parabola/mkgmap/osmstyle/housenumber/HousenumberGroup.java (revision 3631) +++ src/uk/me/parabola/mkgmap/osmstyle/housenumber/HousenumberGroup.java (working copy) @@ -164,9 +164,11 @@ if (timesToAdd == 2){ // add two new points between c1 and c2 points.add(seg + 1, pointToUse); + pointToUse.setAddedNumberNode(true); pointToUse = new Coord (pointToUse); pointToUse.setNumberNode(true); points.add(seg + 1, pointToUse); + pointToUse.setAddedNumberNode(true); linkNode = pointToUse; } else { // copy it @@ -174,6 +176,7 @@ pointToUse.setNumberNode(true); // add copy before c2 points.add(seg + 1, pointToUse); + pointToUse.setAddedNumberNode(true); if (pointToUse.highPrecEquals(c1)){ linkNode = c1; } else {