source: josm/trunk/src/org/openstreetmap/josm/data/Bounds.java@ 6388

Last change on this file since 6388 was 6380, checked in by Don-vip, 10 years ago

update license/copyright information
  • Property svn:eol-style set to native
File size: 16.4 KB
Line 
1// License: GPL. For details, see LICENSE file.
2package org.openstreetmap.josm.data;
3
4import static org.openstreetmap.josm.tools.I18n.tr;
5
6import java.awt.geom.Rectangle2D;
7import java.text.DecimalFormat;
8import java.text.MessageFormat;
9
10import org.openstreetmap.josm.data.coor.LatLon;
11import org.openstreetmap.josm.data.osm.BBox;
12import org.openstreetmap.josm.tools.CheckParameterUtil;
13
14/**
15 * This is a simple data class for "rectangular" areas of the world, given in
16 * lat/lon min/max values. The values are rounded to LatLon.OSM_SERVER_PRECISION
17 *
18 * @author imi
19 */
20public class Bounds {
21 /**
22 * The minimum and maximum coordinates.
23 */
24 private double minLat, minLon, maxLat, maxLon;
25
26 public LatLon getMin() {
27 return new LatLon(minLat, minLon);
28 }
29
30 /**
31 * Returns min latitude of bounds. Efficient shortcut for {@code getMin().lat()}.
32 *
33 * @return min latitude of bounds.
34 * @since 6203
35 */
36 public double getMinLat() {
37 return minLat;
38 }
39
40 /**
41 * Returns min longitude of bounds. Efficient shortcut for {@code getMin().lon()}.
42 *
43 * @return min longitude of bounds.
44 * @since 6203
45 */
46 public double getMinLon() {
47 return minLon;
48 }
49
50 public LatLon getMax() {
51 return new LatLon(maxLat, maxLon);
52 }
53
54 /**
55 * Returns max latitude of bounds. Efficient shortcut for {@code getMax().lat()}.
56 *
57 * @return max latitude of bounds.
58 * @since 6203
59 */
60 public double getMaxLat() {
61 return maxLat;
62 }
63
64 /**
65 * Returns max longitude of bounds. Efficient shortcut for {@code getMax().lon()}.
66 *
67 * @return max longitude of bounds.
68 * @since 6203
69 */
70 public double getMaxLon() {
71 return maxLon;
72 }
73
74 public enum ParseMethod {
75 MINLAT_MINLON_MAXLAT_MAXLON,
76 LEFT_BOTTOM_RIGHT_TOP
77 }
78
79 /**
80 * Construct bounds out of two points. Coords will be rounded.
81 */
82 public Bounds(LatLon min, LatLon max) {
83 this(min.lat(), min.lon(), max.lat(), max.lon());
84 }
85
86 public Bounds(LatLon min, LatLon max, boolean roundToOsmPrecision) {
87 this(min.lat(), min.lon(), max.lat(), max.lon(), roundToOsmPrecision);
88 }
89
90 public Bounds(LatLon b) {
91 this(b, true);
92 }
93
94 /**
95 * Single point Bounds defined by lat/lon {@code b}.
96 * Coordinates will be rounded to osm precision if {@code roundToOsmPrecision} is true.
97 *
98 * @param b lat/lon of given point.
99 * @param roundToOsmPrecision defines if lat/lon will be rounded.
100 */
101 public Bounds(LatLon b, boolean roundToOsmPrecision) {
102 this(b.lat(), b.lon(), roundToOsmPrecision);
103 }
104
105 /**
106 * Single point Bounds defined by point [lat,lon].
107 * Coordinates will be rounded to osm precision if {@code roundToOsmPrecision} is true.
108 *
109 * @param lat latitude of given point.
110 * @param lon longitude of given point.
111 * @param roundToOsmPrecision defines if lat/lon will be rounded.
112 * @since 6203
113 */
114 public Bounds(double lat, double lon, boolean roundToOsmPrecision) {
115 // Do not call this(b, b) to avoid GPX performance issue (see #7028) until roundToOsmPrecision() is improved
116 if (roundToOsmPrecision) {
117 this.minLat = LatLon.roundToOsmPrecision(lat);
118 this.minLon = LatLon.roundToOsmPrecision(lon);
119 } else {
120 this.minLat = lat;
121 this.minLon = lon;
122 }
123 this.maxLat = this.minLat;
124 this.maxLon = this.minLon;
125 }
126
127 public Bounds(double minlat, double minlon, double maxlat, double maxlon) {
128 this(minlat, minlon, maxlat, maxlon, true);
129 }
130
131 public Bounds(double minlat, double minlon, double maxlat, double maxlon, boolean roundToOsmPrecision) {
132 if (roundToOsmPrecision) {
133 this.minLat = LatLon.roundToOsmPrecision(minlat);
134 this.minLon = LatLon.roundToOsmPrecision(minlon);
135 this.maxLat = LatLon.roundToOsmPrecision(maxlat);
136 this.maxLon = LatLon.roundToOsmPrecision(maxlon);
137 } else {
138 this.minLat = minlat;
139 this.minLon = minlon;
140 this.maxLat = maxlat;
141 this.maxLon = maxlon;
142 }
143 }
144
145 public Bounds(double [] coords) {
146 this(coords, true);
147 }
148
149 public Bounds(double [] coords, boolean roundToOsmPrecision) {
150 CheckParameterUtil.ensureParameterNotNull(coords, "coords");
151 if (coords.length != 4)
152 throw new IllegalArgumentException(MessageFormat.format("Expected array of length 4, got {0}", coords.length));
153 if (roundToOsmPrecision) {
154 this.minLat = LatLon.roundToOsmPrecision(coords[0]);
155 this.minLon = LatLon.roundToOsmPrecision(coords[1]);
156 this.maxLat = LatLon.roundToOsmPrecision(coords[2]);
157 this.maxLon = LatLon.roundToOsmPrecision(coords[3]);
158 } else {
159 this.minLat = coords[0];
160 this.minLon = coords[1];
161 this.maxLat = coords[2];
162 this.maxLon = coords[3];
163 }
164 }
165
166 public Bounds(String asString, String separator) throws IllegalArgumentException {
167 this(asString, separator, ParseMethod.MINLAT_MINLON_MAXLAT_MAXLON);
168 }
169
170 public Bounds(String asString, String separator, ParseMethod parseMethod) throws IllegalArgumentException {
171 this(asString, separator, parseMethod, true);
172 }
173
174 public Bounds(String asString, String separator, ParseMethod parseMethod, boolean roundToOsmPrecision) throws IllegalArgumentException {
175 CheckParameterUtil.ensureParameterNotNull(asString, "asString");
176 String[] components = asString.split(separator);
177 if (components.length != 4)
178 throw new IllegalArgumentException(MessageFormat.format("Exactly four doubles expected in string, got {0}: {1}", components.length, asString));
179 double[] values = new double[4];
180 for (int i=0; i<4; i++) {
181 try {
182 values[i] = Double.parseDouble(components[i]);
183 } catch(NumberFormatException e) {
184 throw new IllegalArgumentException(MessageFormat.format("Illegal double value ''{0}''", components[i]));
185 }
186 }
187
188 switch (parseMethod) {
189 case LEFT_BOTTOM_RIGHT_TOP:
190 this.minLat = initLat(values[1], roundToOsmPrecision);
191 this.minLon = initLon(values[0], roundToOsmPrecision);
192 this.maxLat = initLat(values[3], roundToOsmPrecision);
193 this.maxLon = initLon(values[2], roundToOsmPrecision);
194 break;
195 case MINLAT_MINLON_MAXLAT_MAXLON:
196 default:
197 this.minLat = initLat(values[0], roundToOsmPrecision);
198 this.minLon = initLon(values[1], roundToOsmPrecision);
199 this.maxLat = initLat(values[2], roundToOsmPrecision);
200 this.maxLon = initLon(values[3], roundToOsmPrecision);
201 }
202 }
203
204 protected static double initLat(double value, boolean roundToOsmPrecision) {
205 if (!LatLon.isValidLat(value))
206 throw new IllegalArgumentException(tr("Illegal latitude value ''{0}''", value));
207 return roundToOsmPrecision ? LatLon.roundToOsmPrecision(value) : value;
208 }
209
210 protected static double initLon(double value, boolean roundToOsmPrecision) {
211 if (!LatLon.isValidLon(value))
212 throw new IllegalArgumentException(tr("Illegal longitude value ''{0}''", value));
213 return roundToOsmPrecision ? LatLon.roundToOsmPrecision(value) : value;
214 }
215
216 /**
217 * Creates new {@code Bounds} from an existing one.
218 * @param other The bounds to copy
219 */
220 public Bounds(final Bounds other) {
221 this(other.minLat, other.minLon, other.maxLat, other.maxLon);
222 }
223
224 public Bounds(Rectangle2D rect) {
225 this(rect.getMinY(), rect.getMinX(), rect.getMaxY(), rect.getMaxX());
226 }
227
228 /**
229 * Creates new bounds around a coordinate pair <code>center</code>. The
230 * new bounds shall have an extension in latitude direction of <code>latExtent</code>,
231 * and in longitude direction of <code>lonExtent</code>.
232 *
233 * @param center the center coordinate pair. Must not be null.
234 * @param latExtent the latitude extent. > 0 required.
235 * @param lonExtent the longitude extent. > 0 required.
236 * @throws IllegalArgumentException thrown if center is null
237 * @throws IllegalArgumentException thrown if latExtent <= 0
238 * @throws IllegalArgumentException thrown if lonExtent <= 0
239 */
240 public Bounds(LatLon center, double latExtent, double lonExtent) {
241 CheckParameterUtil.ensureParameterNotNull(center, "center");
242 if (latExtent <= 0.0)
243 throw new IllegalArgumentException(MessageFormat.format("Parameter ''{0}'' > 0.0 exptected, got {1}", "latExtent", latExtent));
244 if (lonExtent <= 0.0)
245 throw new IllegalArgumentException(MessageFormat.format("Parameter ''{0}'' > 0.0 exptected, got {1}", "lonExtent", lonExtent));
246
247 this.minLat = LatLon.roundToOsmPrecision(LatLon.toIntervalLat(center.lat() - latExtent / 2));
248 this.minLon = LatLon.roundToOsmPrecision(LatLon.toIntervalLon(center.lon() - lonExtent / 2));
249 this.maxLat = LatLon.roundToOsmPrecision(LatLon.toIntervalLat(center.lat() + latExtent / 2));
250 this.maxLon = LatLon.roundToOsmPrecision(LatLon.toIntervalLon(center.lon() + lonExtent / 2));
251 }
252
253 /**
254 * Creates BBox with same coordinates.
255 *
256 * @return BBox with same coordinates.
257 * @since 6203
258 */
259 public BBox toBBox() {
260 return new BBox(minLon, minLat, maxLon, maxLat);
261 }
262
263 @Override public String toString() {
264 return "Bounds["+minLat+","+minLon+","+maxLat+","+maxLon+"]";
265 }
266
267 public String toShortString(DecimalFormat format) {
268 return
269 format.format(minLat) + " "
270 + format.format(minLon) + " / "
271 + format.format(maxLat) + " "
272 + format.format(maxLon);
273 }
274
275 /**
276 * @return Center of the bounding box.
277 */
278 public LatLon getCenter()
279 {
280 if (crosses180thMeridian()) {
281 double lat = (minLat + maxLat) / 2;
282 double lon = (minLon + maxLon - 360.0) / 2;
283 if (lon < -180.0){
284 lon += 360.0;
285 }
286 return new LatLon(lat, lon);
287 } else {
288 return new LatLon((minLat + maxLat) / 2, (minLon + maxLon) / 2);
289 }
290 }
291
292 /**
293 * Extend the bounds if necessary to include the given point.
294 * @param ll The point to include into these bounds
295 */
296 public void extend(LatLon ll) {
297 extend(ll.lat(), ll.lon());
298 }
299
300 /**
301 * Extend the bounds if necessary to include the given point [lat,lon].
302 * Good to use if you know coordinates to avoid creation of LatLon object.
303 * @param lat Latitude of point to include into these bounds
304 * @param lon Longitude of point to include into these bounds
305 * @since 6203
306 */
307 public void extend(final double lat, final double lon) {
308 if (lat < minLat) {
309 minLat = LatLon.roundToOsmPrecision(lat);
310 }
311 if (lat > maxLat) {
312 maxLat = LatLon.roundToOsmPrecision(lat);
313 }
314 if (crosses180thMeridian()) {
315 if (lon > maxLon && lon < minLon) {
316 if (Math.abs(lon - minLon) <= Math.abs(lon - maxLon)) {
317 minLon = LatLon.roundToOsmPrecision(lon);
318 } else {
319 maxLon = LatLon.roundToOsmPrecision(lon);
320 }
321 }
322 } else {
323 if (lon < minLon) {
324 minLon = LatLon.roundToOsmPrecision(lon);
325 }
326 if (lon > maxLon) {
327 maxLon = LatLon.roundToOsmPrecision(lon);
328 }
329 }
330 }
331
332 public void extend(Bounds b) {
333 extend(b.minLat, b.minLon);
334 extend(b.maxLat, b.maxLon);
335 }
336
337 /**
338 * Determines if the given point {@code ll} is within these bounds.
339 * @param ll The lat/lon to check
340 * @return {@code true} if {@code ll} is within these bounds, {@code false} otherwise
341 */
342 public boolean contains(LatLon ll) {
343 if (ll.lat() < minLat || ll.lat() > maxLat)
344 return false;
345 if (crosses180thMeridian()) {
346 if (ll.lon() > maxLon && ll.lon() < minLon)
347 return false;
348 } else {
349 if (ll.lon() < minLon || ll.lon() > maxLon)
350 return false;
351 }
352 return true;
353 }
354
355 private static boolean intersectsLonCrossing(Bounds crossing, Bounds notCrossing) {
356 return notCrossing.minLon <= crossing.maxLon || notCrossing.maxLon >= crossing.minLon;
357 }
358
359 /**
360 * The two bounds intersect? Compared to java Shape.intersects, if does not use
361 * the interior but the closure. (">=" instead of ">")
362 */
363 public boolean intersects(Bounds b) {
364 if (b.maxLat < minLat || b.minLat > maxLat)
365 return false;
366
367 if (crosses180thMeridian() && !b.crosses180thMeridian()) {
368 return intersectsLonCrossing(this, b);
369 } else if (!crosses180thMeridian() && b.crosses180thMeridian()) {
370 return intersectsLonCrossing(b, this);
371 } else if (crosses180thMeridian() && b.crosses180thMeridian()) {
372 return true;
373 } else {
374 return b.maxLon >= minLon && b.minLon <= maxLon;
375 }
376 }
377
378 /**
379 * Determines if this Bounds object crosses the 180th Meridian.
380 * See http://wiki.openstreetmap.org/wiki/180th_meridian
381 * @return true if this Bounds object crosses the 180th Meridian.
382 */
383 public boolean crosses180thMeridian() {
384 return this.minLon > this.maxLon;
385 }
386
387 /**
388 * Converts the lat/lon bounding box to an object of type Rectangle2D.Double
389 * @return the bounding box to Rectangle2D.Double
390 */
391 public Rectangle2D.Double asRect() {
392 double w = maxLon-minLon + (crosses180thMeridian() ? 360.0 : 0.0);
393 return new Rectangle2D.Double(minLon, minLat, w, maxLat-minLat);
394 }
395
396 public double getArea() {
397 double w = maxLon-minLon + (crosses180thMeridian() ? 360.0 : 0.0);
398 return w * (maxLat - minLat);
399 }
400
401 public String encodeAsString(String separator) {
402 StringBuffer sb = new StringBuffer();
403 sb.append(minLat).append(separator).append(minLon)
404 .append(separator).append(maxLat).append(separator)
405 .append(maxLon);
406 return sb.toString();
407 }
408
409 /**
410 * <p>Replies true, if this bounds are <em>collapsed</em>, i.e. if the min
411 * and the max corner are equal.</p>
412 *
413 * @return true, if this bounds are <em>collapsed</em>
414 */
415 public boolean isCollapsed() {
416 return Double.doubleToLongBits(minLat) == Double.doubleToLongBits(maxLat)
417 && Double.doubleToLongBits(minLon) == Double.doubleToLongBits(maxLon);
418 }
419
420 public boolean isOutOfTheWorld() {
421 return
422 minLat < -90 || minLat > 90 ||
423 maxLat < -90 || maxLat > 90 ||
424 minLon < -180 || minLon > 180 ||
425 maxLon < -180 || maxLon > 180;
426 }
427
428 public void normalize() {
429 minLat = LatLon.toIntervalLat(minLat);
430 maxLat = LatLon.toIntervalLat(maxLat);
431 minLon = LatLon.toIntervalLon(minLon);
432 maxLon = LatLon.toIntervalLon(maxLon);
433 }
434
435 @Override
436 public int hashCode() {
437 final int prime = 31;
438 int result = 1;
439 long temp;
440 temp = Double.doubleToLongBits(maxLat);
441 result = prime * result + (int) (temp ^ (temp >>> 32));
442 temp = Double.doubleToLongBits(maxLon);
443 result = prime * result + (int) (temp ^ (temp >>> 32));
444 temp = Double.doubleToLongBits(minLat);
445 result = prime * result + (int) (temp ^ (temp >>> 32));
446 temp = Double.doubleToLongBits(minLon);
447 result = prime * result + (int) (temp ^ (temp >>> 32));
448 return result;
449 }
450
451 @Override
452 public boolean equals(Object obj) {
453 if (this == obj)
454 return true;
455 if (obj == null)
456 return false;
457 if (getClass() != obj.getClass())
458 return false;
459 Bounds other = (Bounds) obj;
460 if (Double.doubleToLongBits(maxLat) != Double.doubleToLongBits(other.maxLat))
461 return false;
462 if (Double.doubleToLongBits(maxLon) != Double.doubleToLongBits(other.maxLon))
463 return false;
464 if (Double.doubleToLongBits(minLat) != Double.doubleToLongBits(other.minLat))
465 return false;
466 if (Double.doubleToLongBits(minLon) != Double.doubleToLongBits(other.minLon))
467 return false;
468 return true;
469 }
470}
Note: See TracBrowser for help on using the repository browser.