Index: src/uk/me/parabola/mkgmap/osmstyle/StyledConverter.java =================================================================== --- src/uk/me/parabola/mkgmap/osmstyle/StyledConverter.java (revision 1052) +++ src/uk/me/parabola/mkgmap/osmstyle/StyledConverter.java (working copy) @@ -21,6 +21,7 @@ import java.util.IdentityHashMap; import java.util.HashSet; import java.util.List; +import java.util.ListIterator; import java.util.Map; import java.util.Properties; import java.util.Set; @@ -243,10 +244,28 @@ * @param relation The relation to convert. */ public void convertRelation(Relation relation) { - // Relations never resolve to a GType and so we ignore the return - // value. - relationRules.resolveType(relation); + // If the relation resolves to a GType of a way then add that way to the map + preConvertRules(relation); + GType foundType = relationRules.resolveType(relation); + if (foundType != null) { + postConvertRules(relation, foundType); + List elements = relation.getElements(); + // Extract all the ways that belong to the relation + List ways = new ArrayList(elements.size()); + for (Element el : elements) { + if (el instanceof Way) + addWayToListAndChainIfPossible(ways, (Way) el, foundType.isRoad()); // care about oneways if it is a road + } + for (Way w : ways) { + w.setName(relation.getName()); + if (foundType.isRoad()) + addRoad(w, foundType); + else + addLine(w, foundType); + } + } + if(relation instanceof RestrictionRelation) { RestrictionRelation rr = (RestrictionRelation)relation; if(rr.isValid()) { @@ -260,6 +279,133 @@ } } + private void addWayToListAndChainIfPossible(List ways, Way newWay, boolean careAboutOneways) { + outer_loop: for (;;) { + List newWayCoords = newWay.getPoints(); + int newWayNumPoints = newWayCoords.size(); + if (newWayNumPoints == 0) return; + + Coord newWayFirstCoord = newWayCoords.get(0); + Coord newWayLastCoord = newWayCoords.get(newWayNumPoints-1); + + ListIterator listIterator = ways.listIterator(); + while (listIterator.hasNext()) { + Way existantWay = listIterator.next(); + List existantWayCoords = existantWay.getPoints(); + int existantWayNumPoints = existantWayCoords.size(); + if (existantWayNumPoints == 0) continue; + + Coord existantWayFirstCoord = existantWayCoords.get(0); + Coord existantWayLastCoord = existantWayCoords.get(existantWayNumPoints-1); + + // Test coordinates to see whether two way can be chained together + // If they are chained together the only tag we will copy is the oneway tag (if we care about them). + // Access tags will have to be set by the relation! + // TODO: Handle the oneway=-1 tag in a useful way, now it prevents chaining of the ways. + + // Both ways share the same first point. So the new way is connected in reverse, but if we care about oneways + // then only if none of them is one. + if (existantWayFirstCoord.equals(newWayFirstCoord) + && (careAboutOneways || (!existantWay.isBoolTag("oneway") && !newWay.isBoolTag("oneway")))) { + + Way replacementWay = new Way(existantWay.getId()); + + // Add points of new way in reverse + ListIterator newWayCoordIterator = newWayCoords.listIterator(newWayNumPoints); + while (newWayCoordIterator.hasPrevious()) { + replacementWay.addPoint(newWayCoordIterator.previous()); + } + // And of the existant way in order (starting from the second point) + ListIterator existantWayCoordIterator = existantWayCoords.listIterator(1); + while (existantWayCoordIterator.hasNext()) { + replacementWay.addPoint(existantWayCoordIterator.next()); + } + // Remove the existant way that was chained to the new way and start the search again. + listIterator.remove(); + newWay = replacementWay; + continue outer_loop; + // The last point of the existant way is the same as the first point of the new way, so they are + // connected in order, but if we care about oneways then only if they either both have the oneway tag or both have not. + } else if (existantWayLastCoord.equals(newWayFirstCoord) + && (careAboutOneways || !(existantWay.isBoolTag("oneway") ^ newWay.isBoolTag("oneway")))) { + + Way replacementWay = new Way(existantWay.getId()); + if (careAboutOneways) { + String onewayValue = existantWay.getTag("oneway"); + if (onewayValue != null) + replacementWay.addTag("oneway",onewayValue); + } + + // Add points of existant way in order + ListIterator existantWayCoordIterator = existantWayCoords.listIterator(); + while (existantWayCoordIterator.hasNext()) { + replacementWay.addPoint(existantWayCoordIterator.next()); + } + // And of the new way also in order (starting from the second point) + ListIterator newWayCoordIterator = newWayCoords.listIterator(1); + while (newWayCoordIterator.hasNext()) { + replacementWay.addPoint(newWayCoordIterator.next()); + } + // Remove the existant way that was chained to the new way and start the search again. + listIterator.remove(); + newWay = replacementWay; + continue outer_loop; + // The first point of the existant way is the same as the last point of the new way, so connect them, + // but starting with the new way and if we care about oneways then only if they either both have the + // oneway tag or both have not. + } else if (existantWayFirstCoord.equals(newWayLastCoord) + && (careAboutOneways || (!(existantWay.isBoolTag("oneway") ^ newWay.isBoolTag("oneway"))))) { + + Way replacementWay = new Way(existantWay.getId()); + if (careAboutOneways) { + String onewayValue = existantWay.getTag("oneway"); + if (onewayValue != null) + replacementWay.addTag("oneway",onewayValue); + } + + // Add points of the new way in order + ListIterator newWayCoordIterator = newWayCoords.listIterator(); + while (newWayCoordIterator.hasNext()) { + replacementWay.addPoint(newWayCoordIterator.next()); + } + // And of the existant way also in order (starting from the second point) + ListIterator existantWayCoordIterator = existantWayCoords.listIterator(1); + while (existantWayCoordIterator.hasNext()) { + replacementWay.addPoint(existantWayCoordIterator.next()); + } + // Remove the existant way that was chained to the new way and start the search again. + listIterator.remove(); + newWay = replacementWay; + continue outer_loop; + // The last points of the existant and the new way are the same. So the new way is connected in reverse, + // but if we care about oneways than only if neither of them has the oneway tag set. + } else if (existantWayLastCoord.equals(newWayLastCoord) + && (careAboutOneways || (!existantWay.isBoolTag("oneway") && !newWay.isBoolTag("oneway")))) { + + Way replacementWay = new Way(existantWay.getId()); + + // Add points of existant way in order + ListIterator existantWayCoordIterator = existantWayCoords.listIterator(); + while (existantWayCoordIterator.hasNext()) { + replacementWay.addPoint(existantWayCoordIterator.next()); + } + // And of the new way in reverse (starting from the second last point) + ListIterator newWayCoordIterator = newWayCoords.listIterator(newWayNumPoints-1); + while (newWayCoordIterator.hasPrevious()) { + replacementWay.addPoint(newWayCoordIterator.previous()); + } + // Remove the existant way that was chained to the new way and start the search again. + listIterator.remove(); + newWay = replacementWay; + continue outer_loop; + } + } + // If we get here no way was found anymore that we could chain to. Add the way and return. + ways.add(newWay); + return; + } + } + private void addLine(Way way, GType gt) { MapLine line = new MapLine(); elementSetup(line, gt, way); Index: src/uk/me/parabola/mkgmap/reader/osm/Element.java =================================================================== --- src/uk/me/parabola/mkgmap/reader/osm/Element.java (revision 1052) +++ src/uk/me/parabola/mkgmap/reader/osm/Element.java (working copy) @@ -86,7 +86,11 @@ * element. */ public void copyTags(Element other) { - tags = other.tags.copy(); + Tags otherTags = other.tags; + if (otherTags == null) + tags = null; + else + tags = other.tags.copy(); } public String getName() {