Changeset 11247 in josm for trunk/src/org/openstreetmap/josm/tools/RightAndLefthandTraffic.java

Timestamp:

2016-11-13T00:29:31+01:00 (7 years ago)

Author:

Don-vip

Message:

see #9400 - see #10387 - see #12914 - initial implementation of boundaries file, replacing left-right-hand-traffic.osm, discourage contributors to use operator=RFF and operator=ERDF in France (territories rules must be manually eabled on existing installations)

File:

• trunk/src/org/openstreetmap/josm/tools/RightAndLefthandTraffic.java (modified) (2 diffs)

trunk/src/org/openstreetmap/josm/tools/RightAndLefthandTraffic.java

@@ -3 +3 @@
 
 import java.awt.geom.Area;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.Writer;
+import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.Collection;
-
+import java.util.Collections;
+import java.util.List;
+import java.util.Set;
+
+import org.openstreetmap.josm.Main;
+import org.openstreetmap.josm.actions.JoinAreasAction;
+import org.openstreetmap.josm.actions.JoinAreasAction.JoinAreasResult;
+import org.openstreetmap.josm.actions.JoinAreasAction.Multipolygon;
+import org.openstreetmap.josm.actions.PurgeAction;
 import org.openstreetmap.josm.data.coor.LatLon;
 import org.openstreetmap.josm.data.osm.BBox;
 import org.openstreetmap.josm.data.osm.DataSet;
+import org.openstreetmap.josm.data.osm.OsmPrimitive;
+import org.openstreetmap.josm.data.osm.Relation;
+import org.openstreetmap.josm.data.osm.RelationMember;
 import org.openstreetmap.josm.data.osm.Way;
-import org.openstreetmap.josm.io.CachedFile;
 import org.openstreetmap.josm.io.IllegalDataException;
 import org.openstreetmap.josm.io.OsmReader;
+import org.openstreetmap.josm.io.OsmWriter;
+import org.openstreetmap.josm.io.OsmWriterFactory;
 import org.openstreetmap.josm.tools.GeoPropertyIndex.GeoProperty;
 import org.openstreetmap.josm.tools.Geometry.PolygonIntersection;
@@ -58 +77 @@
      * Check if there is right-hand traffic at a certain location.
      *
-     * TODO: Synchronization can be refined inside the {@link GeoPropertyIndex}
-     *       as most look-ups are read-only.
      * @param ll the coordinates of the point
      * @return true if there is right-hand traffic, false if there is left-hand traffic
      */
     public static synchronized boolean isRightHandTraffic(LatLon ll) {
-        if (leftHandTrafficPolygons == null) {
-            initialize();
-        }
         return !rlCache.get(ll);
     }
 
-    private static void initialize() {
+    /**
+     * Initializes Right and lefthand traffic data.
+     * TODO: Synchronization can be refined inside the {@link GeoPropertyIndex} as most look-ups are read-only.
+     */
+    public static synchronized void initialize() {
         leftHandTrafficPolygons = new ArrayList<>();
-        try (CachedFile cf = new CachedFile("resource://data/left-right-hand-traffic.osm");
-                InputStream is = cf.getInputStream()) {
-            DataSet data = OsmReader.parseDataSet(is, null);
-            for (Way w : data.getWays()) {
-                leftHandTrafficPolygons.add(Geometry.getAreaLatLon(w.getNodes()));
-            }
-        } catch (IOException | IllegalDataException ex) {
+        Collection<Way> optimizedWays = loadOptimizedBoundaries();
+        if (optimizedWays.isEmpty()) {
+            optimizedWays = computeOptimizedBoundaries();
+            saveOptimizedBoundaries(optimizedWays);
+        }
+        for (Way w : optimizedWays) {
+            leftHandTrafficPolygons.add(Geometry.getAreaLatLon(w.getNodes()));
+        }
+        rlCache = new GeoPropertyIndex<>(new RLTrafficGeoProperty(), 24);
+    }
+
+    private static Collection<Way> computeOptimizedBoundaries() {
+        Collection<Way> ways = new ArrayList<>();
+        Collection<OsmPrimitive> toPurge = new ArrayList<>();
+        // Find all outer ways of left-driving countries. Many of them are adjacent (African and Asian states)
+        DataSet data = Territories.getDataSet();
+        Collection<Relation> allRelations = data.getRelations();
+        Collection<Way> allWays = data.getWays();
+        for (Way w : allWays) {
+            if ("left".equals(w.get("driving_side"))) {
+                addWayIfNotInner(ways, w);
+            }
+        }
+        for (Relation r : allRelations) {
+            if (r.isMultipolygon() && "left".equals(r.get("driving_side"))) {
+                for (RelationMember rm : r.getMembers()) {
+                    if (rm.isWay() && "outer".equals(rm.getRole())) {
+                        addWayIfNotInner(ways, (Way) rm.getMember());
+                    }
+                }
+            }
+        }
+        toPurge.addAll(allRelations);
+        toPurge.addAll(allWays);
+        toPurge.removeAll(ways);
+        // Remove ways from parent relations for following optimizations
+        for (Relation r : OsmPrimitive.getParentRelations(ways)) {
+            r.setMembers(null);
+        }
+        // Remove all tags to avoid any conflict
+        for (Way w : ways) {
+            w.removeAll();
+        }
+        // Purge all other ways and relations so dataset only contains lefthand traffic data
+        new PurgeAction().doPurge(toPurge, false);
+        // Combine adjacent countries into a single polygon
+        Collection<Way> optimizedWays = new ArrayList<>();
+        List<Multipolygon> areas = JoinAreasAction.collectMultipolygons(ways);
+        if (areas != null) {
+            try {
+                JoinAreasResult result = new JoinAreasAction().joinAreas(areas);
+                if (result.hasChanges) {
+                    for (Multipolygon mp : result.polygons) {
+                        optimizedWays.add(mp.outerWay);
+                    }
+                }
+            } catch (UserCancelException ex) {
+                Main.warn(ex);
+            }
+        }
+        if (optimizedWays.isEmpty()) {
+            // Problem: don't optimize
+            Main.warn("Unable to join left-driving countries polygons");
+            optimizedWays.addAll(ways);
+        }
+        return optimizedWays;
+    }
+
+    /**
+     * Adds w to ways, except if it is an inner way of another lefthand driving multipolygon,
+     * as Lesotho in South Africa and Cyprus village in British Cyprus base.
+     * @param ways ways
+     * @param w way
+     */
+    private static void addWayIfNotInner(Collection<Way> ways, Way w) {
+        Set<Way> s = Collections.singleton(w);
+        for (Relation r : OsmPrimitive.getParentRelations(s)) {
+            if (r.isMultipolygon() && "left".equals(r.get("driving_side")) &&
+                "inner".equals(r.getMembersFor(s).iterator().next().getRole())) {
+                if (Main.isDebugEnabled()) {
+                    Main.debug("Skipping " + w.get("name:en") + " because inner part of " + r.get("name:en"));
+                }
+                return;
+            }
+        }
+        ways.add(w);
+    }
+
+    private static void saveOptimizedBoundaries(Collection<Way> optimizedWays) {
+        DataSet ds = optimizedWays.iterator().next().getDataSet();
+        File file = new File(Main.pref.getCacheDirectory(), "left-right-hand-traffic.osm");
+        try (Writer writer = new OutputStreamWriter(new FileOutputStream(file), StandardCharsets.UTF_8);
+             OsmWriter w = OsmWriterFactory.createOsmWriter(new PrintWriter(writer), false, ds.getVersion())
+            ) {
+            w.header(false);
+            w.writeContent(ds);
+            w.footer();
+        } catch (IOException ex) {
             throw new RuntimeException(ex);
         }
-        rlCache = new GeoPropertyIndex<>(new RLTrafficGeoProperty(), 24);
+    }
+
+    private static Collection<Way> loadOptimizedBoundaries() {
+        try (InputStream is = new FileInputStream(new File(Main.pref.getCacheDirectory(), "left-right-hand-traffic.osm"))) {
+           return OsmReader.parseDataSet(is, null).getWays();
+        } catch (IllegalDataException | IOException ex) {
+            Main.trace(ex);
+            return Collections.emptyList();
+        }
     }
 }