Changeset 4580 in josm for trunk/src/org/openstreetmap/josm/data

Timestamp:

06.11.2011 15:00:56 (7 months ago)

Author:

Don-vip

Message:

see #2212 - Allow JOSM to download data crossing the 180th meridian

Location:

trunk/src/org/openstreetmap/josm/data

Files:

• Bounds.java (modified) (7 diffs)
• coor/LatLon.java (modified) (2 diffs)
• osm/DataSet.java (modified) (1 diff)

trunk/src/org/openstreetmap/josm/data/Bounds.java

@@ -141 +141 @@
             throw new IllegalArgumentException(MessageFormat.format("Parameter ''{0}'' > 0.0 exptected, got {1}", "lonExtent", lonExtent));
 
-        this.minLat = LatLon.roundToOsmPrecision(center.lat() - latExtent / 2);
-        this.minLon = LatLon.roundToOsmPrecision(center.lon() - lonExtent / 2);
-        this.maxLat = LatLon.roundToOsmPrecision(center.lat() + latExtent / 2);
-        this.maxLon = LatLon.roundToOsmPrecision(center.lon() + lonExtent / 2);
+        this.minLat = LatLon.roundToOsmPrecision(LatLon.toIntervalLat(center.lat() - latExtent / 2));
+        this.minLon = LatLon.roundToOsmPrecision(LatLon.toIntervalLon(center.lon() - lonExtent / 2));
+        this.maxLat = LatLon.roundToOsmPrecision(LatLon.toIntervalLat(center.lat() + latExtent / 2));
+        this.maxLon = LatLon.roundToOsmPrecision(LatLon.toIntervalLon(center.lon() + lonExtent / 2));
     }
 
@@ -164 +164 @@
     public LatLon getCenter()
     {
-        return getMin().getCenter(getMax());
+        if (crosses180thMeridian()) {
+            LatLon result = new LatLon(minLat, minLon-360.0).getCenter(getMax());
+            if (result.lon() < -180.0) {
+                result.setLocation(result.lon()+360.0, result.lat());
+            }
+            return result;
+        } else {
+            return getMin().getCenter(getMax());
+        }
     }
 
@@ -174 +182 @@
             minLat = LatLon.roundToOsmPrecision(ll.lat());
         }
-        if (ll.lon() < minLon) {
-            minLon = LatLon.roundToOsmPrecision(ll.lon());
-        }
         if (ll.lat() > maxLat) {
             maxLat = LatLon.roundToOsmPrecision(ll.lat());
         }
-        if (ll.lon() > maxLon) {
-            maxLon = LatLon.roundToOsmPrecision(ll.lon());
+        if (crosses180thMeridian()) {
+            if (ll.lon() > maxLon && ll.lon() < minLon) {
+                if (Math.abs(ll.lon() - minLon) <= Math.abs(ll.lon() - maxLon)) {
+                    minLon = LatLon.roundToOsmPrecision(ll.lon());
+                } else {
+                    maxLon = LatLon.roundToOsmPrecision(ll.lon());
+                }
+            }
+        } else {
+            if (ll.lon() < minLon) {
+                minLon = LatLon.roundToOsmPrecision(ll.lon());
+            }
+            if (ll.lon() > maxLon) {
+                maxLon = LatLon.roundToOsmPrecision(ll.lon());
+            }
         }
     }
@@ -189 +207 @@
         extend(b.getMax());
     }
+    
     /**
      * Is the given point within this bounds?
      */
     public boolean contains(LatLon ll) {
-        if (ll.lat() < minLat || ll.lon() < minLon)
-            return false;
-        if (ll.lat() > maxLat || ll.lon() > maxLon)
-            return false;
+        if (ll.lat() < minLat || ll.lat() > maxLat)
+            return false;
+        if (crosses180thMeridian()) {
+            if (ll.lon() > maxLon && ll.lon() < minLon)
+                return false;
+        } else {
+            if (ll.lon() < minLon || ll.lon() > maxLon)
+                return false;
+        }
         return true;
     }
 
+    private static boolean intersectsLonCrossing(Bounds crossing, Bounds notCrossing) {
+        return notCrossing.minLon <= crossing.maxLon || notCrossing.maxLon >= crossing.minLon;
+    }
+    
     /**
      * The two bounds intersect? Compared to java Shape.intersects, if does not use
@@ -205 +233 @@
      */
     public boolean intersects(Bounds b) {
-        return b.maxLat >= minLat &&
-        b.maxLon >= minLon &&
-        b.minLat <= maxLat &&
-        b.minLon <= maxLon;
-    }
-
-
+        if (b.maxLat < minLat || b.minLat > maxLat)
+            return false;
+        
+        if (crosses180thMeridian() && !b.crosses180thMeridian()) {
+            return intersectsLonCrossing(this, b);
+        } else if (!crosses180thMeridian() && b.crosses180thMeridian()) {
+            return intersectsLonCrossing(b, this);
+        } else if (crosses180thMeridian() && b.crosses180thMeridian()) {
+            return true;
+        } else {
+            return b.maxLon >= minLon && b.minLon <= maxLon;
+        }
+    }
+
+    /**
+     * Determines if this Bounds object crosses the 180th Meridian.
+     * See http://wiki.openstreetmap.org/wiki/180th_meridian
+     * @return true if this Bounds object crosses the 180th Meridian.
+     */
+    public boolean crosses180thMeridian() {
+        return this.minLon > this.maxLon;
+    }
+    
     /**
      * Converts the lat/lon bounding box to an object of type Rectangle2D.Double
@@ -217 +261 @@
      */
     public Rectangle2D.Double asRect() {
-        return new Rectangle2D.Double(minLon, minLat, maxLon-minLon, maxLat-minLat);
+        double w = maxLon-minLon + (crosses180thMeridian() ? 360.0 : 0.0);
+        return new Rectangle2D.Double(minLon, minLat, w, maxLat-minLat);
     }
 
     public double getArea() {
-        return (maxLon - minLon) * (maxLat - minLat);
+        double w = maxLon-minLon + (crosses180thMeridian() ? 360.0 : 0.0);
+        return w * (maxLat - minLat);
     }
 
@@ -250 +296 @@
     }
 
-    private double toIntervalLat(double value, double min, double max) {
-        if (value < min)
-            return min;
-        if (value > max)
-            return max;
-        return value;
-    }
-
-    private double toIntervalLon(double value) {
-        if (value < -180 || value > 180) {
-            value = (value + 180) % 360;
-            if (value < 0) {
-                value += 360;
-            }
-            return value - 180;
-        } else
-            return value;
-    }
-
     public void normalize() {
-        minLat = toIntervalLat(minLat, -90, 90);
-        maxLat = toIntervalLat(maxLat, -90, 90);
-        minLon = toIntervalLon(minLon);
-        maxLon = toIntervalLon(maxLon);
+        minLat = LatLon.toIntervalLat(minLat);
+        maxLat = LatLon.toIntervalLat(maxLat);
+        minLon = LatLon.toIntervalLon(minLon);
+        maxLon = LatLon.toIntervalLon(maxLon);
     }
 

trunk/src/org/openstreetmap/josm/data/coor/LatLon.java

@@ -77 +77 @@
                 return isValidLat(lat()) && isValidLon(lon());
         }
+        
+    public static double toIntervalLat(double value) {
+        if (value < -90)
+            return -90;
+        if (value > 90)
+            return 90;
+        return value;
+    }
+
+    /**
+     * Returns a valid OSM longitude [-180,+180] for the given extended longitude value.
+     * For example, a value of -181 will return +179, a value of +181 will return -179. 
+     * @param lon A longitude value not restricted to the [-180,+180] range.
+     */
+    public static double toIntervalLon(double value) {
+        if (isValidLon(value)) {
+            return value;
+        } else {
+            int n = (int) (value + Math.signum(value)*180.0) / 360;
+            return value - n*360.0;
+        }
+    }
         
     /**
@@ -165 +187 @@
      */
     public boolean isWithin(Bounds b) {
-        return lat() >= b.getMin().lat() && lat() <= b.getMax().lat() && lon() > b.getMin().lon() && lon() < b.getMax().lon();
+        return b.contains(this);
     }
 

trunk/src/org/openstreetmap/josm/data/osm/DataSet.java

@@ -1175 +1175 @@
         return ret;
     }
+    
+    /**
+     * Moves all primitives and datasources from DataSet "from" to this DataSet
+     * @param from The source DataSet
+     */
+    public void mergeFrom(DataSet from) {
+        if (from != null) {
+            for (Node n : from.getNodes()) {
+                from.removePrimitive(n);
+                addPrimitive(n);
+            }
+            for (Way w : from.getWays()) {
+                from.removePrimitive(w);
+                addPrimitive(w);
+            }
+            for (Relation r : from.getRelations()) {
+                from.removePrimitive(r);
+                addPrimitive(r);
+            }
+            dataSources.addAll(from.dataSources);
+            from.dataSources.clear();
+        }
+    }
 
     /* --------------------------------------------------------------------------------- */