1 /**************************************************************************
2 * newbucket.hxx -- new bucket routines for better world modeling
4 * Written by Curtis L. Olson, started February 1999.
6 * Copyright (C) 1999 Curtis L. Olson - http://www.flightgear.org/~curt/
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Library General Public
10 * License as published by the Free Software Foundation; either
11 * version 2 of the License, or (at your option) any later version.
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Library General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
23 **************************************************************************/
27 # include <simgear_config.h>
33 #include <simgear/misc/sg_path.hxx>
34 #include <simgear/debug/logstream.hxx>
36 #include "newbucket.hxx"
39 // default constructor
40 SGBucket::SGBucket() :
48 bool SGBucket::isValid() const
50 // The most northerly valid latitude is 89, not 90. There is no tile
51 // whose *bottom* latitude is 90. Similar there is no tile whose left egde
53 return (lon >= -180) &&
60 void SGBucket::make_bad()
66 // constructor for specified location
67 SGBucket::SGBucket(const double dlon, const double dlat) {
68 set_bucket(dlon, dlat);
71 SGBucket::SGBucket(const SGGeod& geod) {
72 set_bucket(geod.getLongitudeDeg(),
73 geod.getLatitudeDeg());
76 // Parse a unique scenery tile index and find the lon, lat, x, and y
77 SGBucket::SGBucket(const long int bindex) {
78 long int index = bindex;
94 /* Calculate the greatest integral value less than
95 * or equal to the given value (floor(x)),
96 * but attribute coordinates close to the boundary to the next
97 * (increasing) integral
99 static int floorWithEpsilon(double x)
101 double diff = x - static_cast<int>(x);
102 if ( (x >= 0.0) || (fabs(diff) < SG_EPSILON) ) {
103 return static_cast<int>(x);
105 return static_cast<int>(x) - 1;
109 // Set the bucket params for the specified lat and lon
110 void SGBucket::set_bucket( double dlon, double dlat )
112 if ((dlon < -180.0) || (dlon >= 180.0)) {
113 SG_LOG(SG_TERRAIN, SG_WARN, "SGBucket::set_bucket: passed longitude:" << dlon);
114 dlon = SGMiscd::normalizePeriodic(-180.0, 180.0, dlon);
117 if ((dlat < -90.0) || (dlat > 90.0)) {
118 SG_LOG(SG_TERRAIN, SG_WARN, "SGBucket::set_bucket: passed latitude" << dlat);
119 dlat = SGMiscd::clip(dlat, -90.0, 90.0);
125 double span = sg_bucket_span( dlat );
126 // we do NOT need to special case lon=180 here, since
127 // normalizePeriodic will never return 180; it will
128 // return -180, which is what we want.
129 lon = floorWithEpsilon(dlon);
131 // find subdivision or super lon if needed
133 /* We have more than one tile per degree of
134 * longitude, so we need an x offset.
136 x = (int)((dlon - lon) / span);
138 /* We have one or more degrees per tile,
139 * so we need to find the base longitude
142 * First we calculate the integral base longitude
143 * (e.g. -85.5 => -86) and then find the greatest
144 * multiple of span that is less than or equal to
147 * That way, the Greenwich Meridian is always
150 lon=static_cast<int>(floor(lon / span) * span);
157 lat = floorWithEpsilon(dlat);
159 // special case when passing in the north pole point (possibly due to
160 // clipping latitude above). Ensures we generate a valid bucket in this
166 /* Latitude base and offset are easier, as
167 * tiles always are 1/8 degree of latitude wide.
169 y = (int)((dlat - lat) * 8);
173 void SGBucket::set_bucket(const SGGeod& geod)
175 set_bucket(geod.getLongitudeDeg(), geod.getLatitudeDeg());
178 // Build the path name for this bucket
179 std::string SGBucket::gen_base_path() const {
181 int top_lon, top_lat, main_lon, main_lat;
187 if ( (lon < 0) && (top_lon * 10 != lon) ) {
191 if ( top_lon >= 0 ) {
197 if ( main_lon < 0 ) {
203 if ( (lat < 0) && (top_lat * 10 != lat) ) {
207 if ( top_lat >= 0 ) {
213 if ( main_lat < 0 ) {
217 snprintf(raw_path, 256, "%c%03d%c%02d/%c%03d%c%02d",
218 hem, top_lon, pole, top_lat,
219 hem, main_lon, pole, main_lat);
221 SGPath path( raw_path );
227 // return width of the tile in degrees
228 double SGBucket::get_width() const {
229 return sg_bucket_span( get_center_lat() );
233 // return height of the tile in degrees
234 double SGBucket::get_height() const {
235 return SG_BUCKET_SPAN;
239 // return width of the tile in meters
240 double SGBucket::get_width_m() const {
241 double clat = (int)get_center_lat();
243 clat = (int)clat + 0.5;
245 clat = (int)clat - 0.5;
247 double clat_rad = clat * SGD_DEGREES_TO_RADIANS;
248 double cos_lat = cos( clat_rad );
249 double local_radius = cos_lat * SG_EQUATORIAL_RADIUS_M;
250 double local_perimeter = local_radius * SGD_2PI;
251 double degree_width = local_perimeter / 360.0;
253 return get_width() * degree_width;
257 // return height of the tile in meters
258 double SGBucket::get_height_m() const {
259 double perimeter = SG_EQUATORIAL_RADIUS_M * SGD_2PI;
260 double degree_height = perimeter / 360.0;
262 return SG_BUCKET_SPAN * degree_height;
265 SGBucket SGBucket::sibling(int dx, int dy) const
268 SG_LOG(SG_TERRAIN, SG_WARN, "SGBucket::sibling: requesting sibling of invalid bucket");
272 double clat = get_center_lat() + dy * SG_BUCKET_SPAN;
273 // return invalid here instead of clipping, so callers can discard
274 // invalid buckets without having to check if it's an existing one
275 if ((clat < -90.0) || (clat > 90.0)) {
279 // find the lon span for the new latitude
280 double span = sg_bucket_span( clat );
282 double tmp = get_center_lon() + dx * span;
283 tmp = SGMiscd::normalizePeriodic(-180.0, 180.0, tmp);
284 return SGBucket(tmp, clat);
287 std::string SGBucket::gen_index_str() const
290 std::snprintf(tmp, 20, "%ld",
291 (((long)lon + 180) << 14) + ((lat + 90) << 6)
293 return (std::string)tmp;
296 // find the bucket which is offset by the specified tile units in the
297 // X & Y direction. We need the current lon and lat to resolve
298 // ambiguities when going from a wider tile to a narrower one above or
299 // below. This assumes that we are feeding in
300 SGBucket sgBucketOffset( double dlon, double dlat, int dx, int dy ) {
301 SGBucket result( dlon, dlat );
302 double clat = result.get_center_lat() + dy * SG_BUCKET_SPAN;
304 // walk dy units in the lat direction
305 result.set_bucket( dlon, clat );
307 // find the lon span for the new latitude
308 double span = sg_bucket_span( clat );
310 // walk dx units in the lon direction
311 double tmp = dlon + dx * span;
312 while ( tmp < -180.0 ) {
315 while ( tmp >= 180.0 ) {
318 result.set_bucket( tmp, clat );
324 // calculate the offset between two buckets
325 void sgBucketDiff( const SGBucket& b1, const SGBucket& b2, int *dx, int *dy ) {
327 // Latitude difference
328 double c1_lat = b1.get_center_lat();
329 double c2_lat = b2.get_center_lat();
330 double diff_lat = c2_lat - c1_lat;
333 *dy = (int)rint( diff_lat / SG_BUCKET_SPAN );
335 if ( diff_lat > 0 ) {
336 *dy = (int)( diff_lat / SG_BUCKET_SPAN + 0.5 );
338 *dy = (int)( diff_lat / SG_BUCKET_SPAN - 0.5 );
342 // longitude difference
347 // To handle crossing the bucket size boundary
348 // we need to account for different size buckets.
350 if ( sg_bucket_span(c1_lat) <= sg_bucket_span(c2_lat) )
352 span = sg_bucket_span(c1_lat);
354 span = sg_bucket_span(c2_lat);
357 diff_lon = b2.get_center_lon() - b1.get_center_lon();
361 diff_lon -= b1.get_width()*0.5 + b2.get_width()*0.5 - span;
365 diff_lon += b1.get_width()*0.5 + b2.get_width()*0.5 - span;
370 *dx = (int)rint( diff_lon / span );
372 if ( diff_lon > 0 ) {
373 *dx = (int)( diff_lon / span + 0.5 );
375 *dx = (int)( diff_lon / span - 0.5 );
380 void sgGetBuckets( const SGGeod& min, const SGGeod& max, std::vector<SGBucket>& list ) {
381 double lon, lat, span;
383 for (lat = min.getLatitudeDeg(); lat <= max.getLatitudeDeg(); lat += SG_BUCKET_SPAN) {
384 span = sg_bucket_span( lat );
385 for (lon = min.getLongitudeDeg(); lon <= max.getLongitudeDeg(); lon += span)
387 SGBucket b(lon, lat);
397 std::ostream& operator<< ( std::ostream& out, const SGBucket& b )
399 return out << b.lon << ":" << (int)b.x << ", " << b.lat << ":" << (int)b.y;