lat = -1000;
}
+#ifndef NO_DEPRECATED_API
+
// constructor for specified location
SGBucket::SGBucket(const double dlon, const double dlat) {
set_bucket(dlon, dlat);
}
+#endif
SGBucket::SGBucket(const SGGeod& geod) {
- set_bucket(geod.getLongitudeDeg(),
- geod.getLatitudeDeg());
+ innerSet(geod.getLongitudeDeg(),
+ geod.getLatitudeDeg());
}
// Parse a unique scenery tile index and find the lon, lat, x, and y
*/
static int floorWithEpsilon(double x)
{
- double diff = x - static_cast<int>(x);
- if ( (x >= 0.0) || (fabs(diff) < SG_EPSILON) ) {
- return static_cast<int>(x);
- } else {
- return static_cast<int>(x) - 1;
- }
+ return static_cast<int>(floor(x + SG_EPSILON));
+}
+
+#ifndef NO_DEPRECATED_API
+
+void SGBucket::set_bucket(double dlon, double dlat)
+{
+ innerSet(dlon, dlat);
}
+
+void SGBucket::set_bucket(const SGGeod& geod)
+{
+ innerSet(geod.getLongitudeDeg(), geod.getLatitudeDeg());
+}
+
+#endif
+
// Set the bucket params for the specified lat and lon
-void SGBucket::set_bucket( double dlon, double dlat )
+void SGBucket::innerSet( double dlon, double dlat )
{
if ((dlon < -180.0) || (dlon >= 180.0)) {
SG_LOG(SG_TERRAIN, SG_WARN, "SGBucket::set_bucket: passed longitude:" << dlon);
/* We have more than one tile per degree of
* longitude, so we need an x offset.
*/
- x = (int)((dlon - lon) / span);
+ x = floorWithEpsilon((dlon - lon) / span);
} else {
/* We have one or more degrees per tile,
* so we need to find the base longitude
/* Latitude base and offset are easier, as
* tiles always are 1/8 degree of latitude wide.
*/
- y = (int)((dlat - lat) * 8);
+ y = floorWithEpsilon((dlat - lat) * 8);
}
}
-void SGBucket::set_bucket(const SGGeod& geod)
-{
- set_bucket(geod.getLongitudeDeg(), geod.getLatitudeDeg());
-}
-
// Build the path name for this bucket
std::string SGBucket::gen_base_path() const {
// long int index;
return SG_BUCKET_SPAN;
}
-
-// return width of the tile in meters
-double SGBucket::get_width_m() const {
- double clat = (int)get_center_lat();
- if ( clat > 0 ) {
- clat = (int)clat + 0.5;
- } else {
- clat = (int)clat - 0.5;
+double SGBucket::get_highest_lat() const
+{
+ unsigned char adjustedY = y;
+ if (lat >= 0) {
+ // tile is north of the equator, so we want the top edge. Add one
+ // to y to achieve this.
+ ++adjustedY;
}
- double clat_rad = clat * SGD_DEGREES_TO_RADIANS;
+
+ return lat + (adjustedY / 8.0);
+}
+
+
+// return width of the tile in meters. This function is used by the
+// tile-manager to estimate how many tiles are in the view distance, so
+// we care about the smallest width, which occurs at the highest latitude.
+double SGBucket::get_width_m() const
+{
+ double clat_rad = get_highest_lat() * SGD_DEGREES_TO_RADIANS;
double cos_lat = cos( clat_rad );
+ if (fabs(cos_lat) < SG_EPSILON) {
+ // happens for polar tiles, since we pass in a latitude of 90
+ // return an arbitrary small value so all tiles are loaded
+ return 10.0;
+ }
+
double local_radius = cos_lat * SG_EQUATORIAL_RADIUS_M;
double local_perimeter = local_radius * SGD_2PI;
double degree_width = local_perimeter / 360.0;
return SG_BUCKET_SPAN * degree_height;
}
+unsigned int SGBucket::siblings( int dx, int dy, std::vector<SGBucket>& buckets ) const
+{
+ if (!isValid()) {
+ SG_LOG(SG_TERRAIN, SG_WARN, "SGBucket::sibling: requesting sibling of invalid bucket");
+ return 0;
+ }
+
+ double src_span = sg_bucket_span( get_center_lat() );
+
+ double clat = get_center_lat() + dy * SG_BUCKET_SPAN;
+ // return invalid here instead of clipping, so callers can discard
+ // invalid buckets without having to check if it's an existing one
+ if ((clat < -90.0) || (clat > 90.0)) {
+ return 0;
+ }
+
+ // find the lon span for the new latitude
+ double trg_span = sg_bucket_span( clat );
+
+ // if target span < src_span, return multiple buckets...
+ if ( trg_span < src_span ) {
+ // calc center longitude of westernmost sibling
+ double start_lon = get_center_lat() - src_span/2 + trg_span/2;
+
+ unsigned int num_buckets = src_span/trg_span;
+ for ( unsigned int x = 0; x < num_buckets; x++ ) {
+ double tmp = start_lon + x * trg_span;
+ tmp = SGMiscd::normalizePeriodic(-180.0, 180.0, tmp);
+
+ SGBucket b;
+ b.innerSet(tmp, clat);
+
+ buckets.push_back( b );
+ }
+ } else {
+ // just return the single sibling
+ double tmp = get_center_lon() + dx * trg_span;
+ tmp = SGMiscd::normalizePeriodic(-180.0, 180.0, tmp);
+
+ SGBucket b;
+ b.innerSet(tmp, clat);
+
+ buckets.push_back( b );
+ }
+
+ return buckets.size();
+}
+
SGBucket SGBucket::sibling(int dx, int dy) const
{
if (!isValid()) {
double tmp = get_center_lon() + dx * span;
tmp = SGMiscd::normalizePeriodic(-180.0, 180.0, tmp);
- return SGBucket(tmp, clat);
+
+ SGBucket b;
+ b.innerSet(tmp, clat);
+ return b;
}
std::string SGBucket::gen_index_str() const
return (std::string)tmp;
}
+#ifndef NO_DEPRECATED_API
// find the bucket which is offset by the specified tile units in the
// X & Y direction. We need the current lon and lat to resolve
// ambiguities when going from a wider tile to a narrower one above or
return result;
}
-
+#endif
// calculate the offset between two buckets
void sgBucketDiff( const SGBucket& b1, const SGBucket& b2, int *dx, int *dy ) {
void sgGetBuckets( const SGGeod& min, const SGGeod& max, std::vector<SGBucket>& list ) {
double lon, lat, span;
- for (lat = min.getLatitudeDeg(); lat <= max.getLatitudeDeg(); lat += SG_BUCKET_SPAN) {
+ for (lat = min.getLatitudeDeg(); lat < max.getLatitudeDeg()+SG_BUCKET_SPAN; lat += SG_BUCKET_SPAN) {
span = sg_bucket_span( lat );
for (lon = min.getLongitudeDeg(); lon <= max.getLongitudeDeg(); lon += span)
{
- SGBucket b(lon, lat);
+ SGBucket b(SGGeod::fromDeg(lon, lat));
if (!b.isValid()) {
continue;
}
projects / simgear.git / blobdiff