Ticket #17131: gpx_distance.patch

src/org/openstreetmap/josm/data/gpx/GpxDistance.java

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.gpx;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import org.openstreetmap.josm.data.coor.LatLon;
+import org.openstreetmap.josm.data.gpx.GpxData;
+import org.openstreetmap.josm.data.gpx.WayPoint;
+import org.openstreetmap.josm.data.osm.Node;
+import org.openstreetmap.josm.data.osm.OsmPrimitive;
+import org.openstreetmap.josm.data.osm.Relation;
+import org.openstreetmap.josm.data.osm.Way;
+import org.openstreetmap.josm.gui.MainApplication;
+import org.openstreetmap.josm.gui.layer.GpxLayer;
+import org.openstreetmap.josm.gui.layer.Layer;
+
+public class GpxDistance {
+    List<Layer> layers;
+    public GpxDistance() {
+        layers = MainApplication.getLayerManager().getLayers();
+    }
+
+    public boolean isCloseTo(OsmPrimitive p, double maximumDistance) {
+        double distance = getLowestDistance(p);
+        return (distance < maximumDistance);
+    }
+
+    /**
+     * Get the lowest distance from the layers to p
+     * @param p
+     * @return
+     */
+    public double getLowestDistance(OsmPrimitive p) {
+        double distance = Double.MAX_VALUE;
+        for (Layer layer : layers) {
+            double tdistance = getLowestDistance(p, layer);
+            if (tdistance < distance) distance = tdistance;
+        }
+        return distance;
+    }
+    /**
+     * Find the distance between a point and a layer of surveyed points
+     * @param p
+     * @param layer
+     * @return The shortest distance
+     */
+    public double getLowestDistance(OsmPrimitive p, Layer layer) {
+        if (layer instanceof GpxLayer) {
+            GpxLayer gpxLayer = (GpxLayer) layer;
+            GpxData gpxData = gpxLayer.data;
+            List<WayPoint> trackPoints = gpxData.getTrackPoints().collect(Collectors.toList());
+            double lowestDistance = Double.MAX_VALUE;
+            for (WayPoint trackPoint : trackPoints) {
+                double distance = getDistance(p, trackPoint);
+                if (distance >= 0.0 && distance < lowestDistance) lowestDistance = distance;
+            }
+            return lowestDistance;
+        }
+        return Double.MAX_VALUE;
+    }
+
+    /**
+     * Get the distance between an object and a waypoint
+     * @param p
+     * @param waypoint
+     * @return The shortest distance between p and waypoint
+     */
+    public double getDistance(OsmPrimitive p, WayPoint waypoint) {
+        if (p instanceof Node) {
+            return getDistanceNode((Node)p, waypoint);
+        } else if (p instanceof Way) {
+            return getDistanceWay((Way)p, waypoint);
+        } else if (p instanceof Relation) {
+            return getDistanceRelation((Relation)p, waypoint);
+        }
+        return Double.MAX_VALUE;
+    }
+
+    /**
+     * Get the shortest distance between a relation and a waypoint
+     * @param relation
+     * @param waypoint
+     * @return The distance between the relationa and the waypoint
+     */
+    protected double getDistanceRelation(Relation relation, WayPoint waypoint) {
+        double shortestDistance = Double.MAX_VALUE;
+        List<Node> nodes = new ArrayList<Node>(relation.getMemberPrimitives(Node.class));
+        List<Way> ways = new ArrayList<Way>(relation.getMemberPrimitives(Way.class));
+        List<Relation> relations = new ArrayList<Relation>(relation.getMemberPrimitives(Relation.class));
+        for (Relation nrelation : relations) {
+            double distance = getDistanceRelation(nrelation, waypoint);
+            if (distance < shortestDistance) shortestDistance = distance;
+        }
+        for (Way way : ways) {
+            double distance = getDistanceWay(way, waypoint);
+            if (distance < shortestDistance) shortestDistance = distance;
+        }
+        for (Node node : nodes) {
+            double distance = getDistanceNode(node, waypoint);
+            if (distance < shortestDistance) shortestDistance = distance;
+        }
+        return shortestDistance;
+    }
+
+    /**
+     * Get the shortest distance between a way and a waypoint
+     * @param way
+     * @param waypoint
+     * @return The distance between the way and the waypoint
+     */
+    protected double getDistanceWay(Way way, WayPoint waypoint) {
+        double shortestDistance = Double.MAX_VALUE;
+        LatLon coords = waypoint.getCoor();
+        for (int i = 0; i < way.getNodesCount() - 1; i++) {
+            LatLon first = way.getNode(i).getCoor();
+            LatLon second = way.getNode(i + 1).getCoor();
+            double distance = Math.abs((second.getY() - first.getY()) * coords.getX() - (second.getX() - first.getX()) * coords.getY()
+                    + second.getX() * first.getY() - second.getY() - first.getX()) /
+                    Math.sqrt(Math.pow(second.getY() - first.getY(), 2) + Math.pow(second.getX() - first.getX(), 2));
+            if (distance < shortestDistance) shortestDistance = distance;
+        }
+        return shortestDistance;
+    }
+
+    /**
+     * Get the distance between a node and a waypoint
+     * @param node
+     * @param waypoint
+     * @return The distance between the two points
+     */
+    protected double getDistanceNode(Node node, WayPoint waypoint) {
+        return waypoint.getCoor().distance(node.getCoor());
+    }
+}

src/org/openstreetmap/josm/gui/mappaint/mapcss/ExpressionFactory.java

@@ -24 +24 @@
 import java.util.zip.CRC32;
 
 import org.openstreetmap.josm.data.coor.LatLon;
+import org.openstreetmap.josm.data.gpx.GpxDistance;
 import org.openstreetmap.josm.data.osm.IPrimitive;
+import org.openstreetmap.josm.data.osm.OsmPrimitive;
 import org.openstreetmap.josm.data.osm.Node;
 import org.openstreetmap.josm.data.osm.Way;
 import org.openstreetmap.josm.data.osm.search.SearchCompiler;
@@ -519 +521 @@
         }
 
         /**
+         * Returns the lowest distance between the OSM object and a GPX point
+         * <p>
+         * @param env the environment
+         * @return the distance between the object and the closest gpx point or {@code Double.MAX_VALUE}
+         */
+        public static double gpx_distance(final Environment env) { // NO_UCD (unused code)
+            if (env.osm instanceof OsmPrimitive) {
+                GpxDistance gpxDistance = new GpxDistance();
+                return gpxDistance.getLowestDistance((OsmPrimitive)env.osm);
+            } else {
+                return Double.MAX_VALUE;
+            }
+        }
+
+        /**
          * Determines whether the object has a tag with the given key.
          * @param env the environment
          * @param key the OSM key