unsigned int
CacheEstimator::getNumTiles() const
{
unsigned int total = 0;
for (unsigned int level = _minLevel; level <= _maxLevel; level++)
{
if (_extents.empty())
{
unsigned int wide, high;
_profile->getNumTiles( level, wide, high );
total += (wide * high);
}
else
{
for (std::vector< GeoExtent >::const_iterator itr = _extents.begin(); itr != _extents.end(); ++itr)
{
const GeoExtent& extent = *itr;
TileKey ll = _profile->createTileKey(extent.xMin(), extent.yMin(), level);
TileKey ur = _profile->createTileKey(extent.xMax(), extent.yMax(), level);
if (!ll.valid() || !ur.valid()) continue;
int tilesWide = ur.getTileX() - ll.getTileX() + 1;
int tilesHigh = ll.getTileY() - ur.getTileY() + 1;
int tilesAtLevel = tilesWide * tilesHigh;
total += tilesAtLevel;
}
}
}
return total;
}
bool
OSGTileFactory::createValidGeoImage(ImageLayer* layer,
const TileKey& key,
GeoImage& out_image,
TileKey& out_actualTileKey,
ProgressCallback* progress)
{
//TODO: Redo this to just grab images from the parent TerrainTiles
//Try to create the image with the given key
out_actualTileKey = key;
while (out_actualTileKey.valid())
{
if ( layer->isKeyValid(out_actualTileKey) )
{
out_image = layer->createImage( out_actualTileKey, progress );
if ( out_image.valid() )
{
return true;
}
}
out_actualTileKey = out_actualTileKey.createParentKey();
}
return false;
}
void
LocalGeometryNode::onTileAdded(const TileKey& key,
osg::Node* graph,
TerrainCallbackContext& context)
{
bool needsClamp;
// This was faster, but less precise and resulted in a lot of unnecessary clamp attempts:
//if ( _boundingPT.contains(patch->getBound()) )
// Does the tile key's polytope intersect the world bounds or this object?
// (taking getParent(0) gives the world-tranformed bounds vs. local bounds)
if (key.valid())
{
osg::Polytope tope;
key.getExtent().createPolytope(tope);
needsClamp = tope.contains(this->getParent(0)->getBound());
}
else
{
// with no key, must clamp no matter what
needsClamp = true;
}
if (needsClamp)
{
clamp(graph, context.getTerrain());
}
}
// This will be called by AnnotationNode when a new terrain tile comes in.
void
FeatureNode::onTileAdded(const TileKey& key,
osg::Node* graph,
TerrainCallbackContext& context)
{
if (!_clampDirty)
{
bool needsClamp;
if (key.valid())
{
osg::Polytope tope;
key.getExtent().createPolytope(tope);
needsClamp = tope.contains(this->getBound());
}
else
{
// without a valid tilekey we don't know the extent of the change,
// so clamping is required.
needsClamp = true;
}
if (needsClamp)
{
_clampDirty = true;
ADJUST_UPDATE_TRAV_COUNT(this, +1);
//clamp(graph, context.getTerrain());
}
}
}
bool
TerrainLayer::isKeyValid(const TileKey& key) const
{
if (!key.valid()) return false;
const TerrainLayerOptions& opt = getTerrainLayerOptions();
//Check to see if explicit levels of detail are set
if ( opt.minLevel().isSet() && (int)key.getLevelOfDetail() < opt.minLevel().value() ) return false;
if ( opt.maxLevel().isSet() && (int)key.getLevelOfDetail() > opt.maxLevel().value() ) return false;
//Check to see if levels of detail based on resolution are set
if (opt.minLevelResolution().isSet())
{
unsigned int minLevel = getProfile()->getLevelOfDetailForHorizResolution( opt.minLevelResolution().value(), getTileSize());
OE_DEBUG << "Computed min level of " << minLevel << std::endl;
if (key.getLevelOfDetail() < minLevel) return false;
}
if (opt.maxLevelResolution().isSet())
{
unsigned int maxLevel = getProfile()->getLevelOfDetailForHorizResolution( opt.maxLevelResolution().value(), getTileSize());
OE_DEBUG << "Computed max level of " << maxLevel << std::endl;
if (key.getLevelOfDetail() > maxLevel) return false;
}
return true;
}
void
TileModelFactory::buildElevation(const TileKey& key,
const MapFrame& frame,
bool accumulate,
TileModel* model,
ProgressCallback* progress)
{
const MapInfo& mapInfo = frame.getMapInfo();
const osgEarth::ElevationInterpolation& interp =
frame.getMapOptions().elevationInterpolation().get();
// Request a heightfield from the map, falling back on lower resolution tiles
// if necessary (fallback=true)
osg::ref_ptr<osg::HeightField> hf;
bool isFallback = false;
if (_hfCache->getOrCreateHeightField(frame, key, accumulate, hf, isFallback, SAMPLE_FIRST_VALID, interp, progress))
{
model->_elevationData = TileModel::ElevationData(
hf,
GeoLocator::createForKey( key, mapInfo ),
isFallback );
// Edge normalization: requires adjacency information
if ( _terrainOptions.normalizeEdges() == true )
{
for( int x=-1; x<=1; x++ )
{
for( int y=-1; y<=1; y++ )
{
if ( x != 0 || y != 0 )
{
TileKey nk = key.createNeighborKey(x, y);
if ( nk.valid() )
{
osg::ref_ptr<osg::HeightField> hf;
if (_hfCache->getOrCreateHeightField(frame, nk, accumulate, hf, isFallback, SAMPLE_FIRST_VALID, interp, progress) )
{
model->_elevationData.setNeighbor( x, y, hf.get() );
}
}
}
}
}
// parent too.
if ( key.getLOD() > 0 )
{
osg::ref_ptr<osg::HeightField> hf;
if ( _hfCache->getOrCreateHeightField(frame, key.createParentKey(), accumulate, hf, isFallback, SAMPLE_FIRST_VALID, interp, progress) )
{
model->_elevationData.setParent( hf.get() );
}
}
}
}
}
void
OSGTileFactory::addPlaceholderHeightfieldLayer(StreamingTile* tile,
StreamingTile* ancestorTile,
GeoLocator* defaultLocator,
const TileKey& key,
const TileKey& ancestorKey)
{
osgTerrain::HeightFieldLayer* newHFLayer = 0L;
if ( ancestorTile && ancestorKey.valid() )
{
osg::ref_ptr<osgTerrain::HeightFieldLayer> ancestorLayer;
{
Threading::ScopedReadLock sharedLock( ancestorTile->getTileLayersMutex() );
ancestorLayer = dynamic_cast<osgTerrain::HeightFieldLayer*>(ancestorTile->getElevationLayer());
}
if ( ancestorLayer.valid() )
{
osg::ref_ptr<osg::HeightField> ancestorHF = ancestorLayer->getHeightField();
if ( ancestorHF.valid() )
{
osg::HeightField* newHF = HeightFieldUtils::createSubSample(
ancestorHF.get(),
ancestorKey.getExtent(),
key.getExtent());
newHFLayer = new osgTerrain::HeightFieldLayer( newHF );
newHFLayer->setLocator( defaultLocator );
// lock to set the elevation layerdata:
{
Threading::ScopedWriteLock exclusiveLock( tile->getTileLayersMutex() );
tile->setElevationLayer( newHFLayer );
tile->setElevationLOD( ancestorTile->getElevationLOD() );
}
}
}
}
// lock the tile to write the elevation data.
{
Threading::ScopedWriteLock exclusiveLock( tile->getTileLayersMutex() );
if ( !newHFLayer )
{
newHFLayer = new osgTerrain::HeightFieldLayer();
newHFLayer->setHeightField( createEmptyHeightField( key, 8, 8 ) );
newHFLayer->setLocator( defaultLocator );
tile->setElevationLOD( -1 );
}
if ( newHFLayer )
{
tile->setElevationLayer( newHFLayer );
}
}
}
osg::Node*
MPTerrainEngineNode::createTile( const TileKey& key )
{
osg::ref_ptr<TileModel> model = new TileModel( _update_mapf->getRevision(), _update_mapf->getMapInfo() );
model->_tileKey = key;
model->_tileLocator = GeoLocator::createForKey(key, _update_mapf->getMapInfo());
// Build the heightfield
const MapInfo& mapInfo = _update_mapf->getMapInfo();
const osgEarth::ElevationInterpolation& interp = _update_mapf->getMapOptions().elevationInterpolation().get();
// Request a heightfield from the map, falling back on lower resolution tiles
osg::ref_ptr<osg::HeightField> hf;
TileKey sampleKey = key;
bool populated = false;
if (_update_mapf->elevationLayers().size() > 0)
{
while (!populated)
{
populated = _update_mapf->populateHeightField(hf, sampleKey, true, SAMPLE_FIRST_VALID);
if (!populated)
{
// Fallback on the parent
sampleKey = sampleKey.createParentKey();
if (!sampleKey.valid())
{
return 0;
}
}
}
}
if (!populated)
{
// We have no heightfield so just create a reference heightfield.
hf = HeightFieldUtils::createReferenceHeightField( key.getExtent(), 15, 15 );
sampleKey = key;
}
model->_elevationData = TileModel::ElevationData(
hf,
GeoLocator::createForKey( sampleKey, mapInfo ),
false );
bool optimizeTriangleOrientation = getMap()->getMapOptions().elevationInterpolation() != INTERP_TRIANGULATE;
osg::ref_ptr<TileModelCompiler> compiler = new TileModelCompiler(
_update_mapf->terrainMaskLayers(),
_update_mapf->modelLayers(),
_primaryUnit,
optimizeTriangleOrientation,
_terrainOptions );
return compiler->compile(model.get(), *_update_mapf, 0L);
}
void
ImageOverlay::onTileAdded(const TileKey& key,
osg::Node* graph,
TerrainCallbackContext& context)
{
if ( graph == 0L || !key.valid() || _boundingPolytope.contains(graph->getBound()) )
{
clamp( graph, context.getTerrain() );
}
}
osg::Node*
RexTerrainEngineNode::createTile( const TileKey& key )
{
// Compute the sample size to use for the key's level of detail that will line up exactly with the tile size of the highest level of subdivision of the rex engine.
unsigned int sampleSize = computeSampleSize( key.getLevelOfDetail() );
OE_INFO << LC << "Computed a sample size of " << sampleSize << " for lod " << key.getLevelOfDetail() << std::endl;
TileKey sampleKey = key;
// ALWAYS use 257x257 b/c that is what rex always uses.
osg::ref_ptr< osg::HeightField > out_hf = HeightFieldUtils::createReferenceHeightField(
key.getExtent(), 257, 257, 0u, true );
sampleKey = key;
bool populated = false;
while (!populated)
{
populated = _update_mapf->populateHeightField(
out_hf,
sampleKey,
true, // convertToHAE
0 );
if (!populated)
{
// Fallback on the parent
sampleKey = sampleKey.createParentKey();
if (!sampleKey.valid())
{
return 0;
}
}
}
// cannot happen (says coverity; see loop above), so commenting this out -gw
#if 0
if (!populated)
{
// We have no heightfield so just create a reference heightfield.
out_hf = HeightFieldUtils::createReferenceHeightField( key.getExtent(), 257, 257, 0u);
sampleKey = key;
}
#endif
GeoHeightField geoHF( out_hf.get(), sampleKey.getExtent() );
if (sampleKey != key)
{
geoHF = geoHF.createSubSample( key.getExtent(), sampleSize, sampleSize, osgEarth::INTERP_BILINEAR);
}
// We should now have a heightfield that matches up exactly with the requested key at the appropriate resolution.
// Turn it into triangles.
return renderHeightField( geoHF );
}
bool
TerrainLayer::isKeyInLegalRange(const TileKey& key) const
{
if ( !key.valid() )
{
return false;
}
// We must use the equivalent lod b/c the input key can be in any profile.
unsigned localLOD = getProfile() ?
getProfile()->getEquivalentLOD(key.getProfile(), key.getLOD()) :
key.getLOD();
// First check the key against the min/max level limits, it they are set.
if ((options().maxLevel().isSet() && localLOD > options().maxLevel().value()) ||
(options().minLevel().isSet() && localLOD < options().minLevel().value()))
{
return false;
}
// Next check the maxDataLevel if that is set.
if (options().maxDataLevel().isSet() && localLOD > options().maxDataLevel().get())
{
return false;
}
// Next, check against resolution limits (based on the source tile size).
if (options().minResolution().isSet() || options().maxResolution().isSet())
{
const Profile* profile = getProfile();
if ( profile )
{
// calculate the resolution in the layer's profile, which can
// be different that the key's profile.
double resKey = key.getExtent().width() / (double)getTileSize();
double resLayer = key.getProfile()->getSRS()->transformUnits(resKey, profile->getSRS());
if (options().maxResolution().isSet() &&
options().maxResolution().value() > resLayer)
{
return false;
}
if (options().minResolution().isSet() &&
options().minResolution().value() < resLayer)
{
return false;
}
}
}
return true;
}
bool
ElevationLayer::isKeyValid(const TileKey& key) const
{
if (!key.valid())
return false;
if ( _runtimeOptions.minLevel().isSet() && key.getLOD() < _runtimeOptions.minLevel().value() )
{
return false;
}
return TerrainLayer::isKeyValid(key);
}
void
Terrain::notifyTileAdded( const TileKey& key, osg::Node* node )
{
if ( !node )
{
OE_WARN << LC << "notify with a null node!" << std::endl;
}
if (_callbacksSize > 0)
{
if (!key.valid())
OE_WARN << LC << "notifyTileAdded with key = NULL\n";
_updateQueue->add(new OnTileAddedOperation(key, node, this));
}
}
bool
TerrainLayer::isKeyInRange(const TileKey& key) const
{
if ( !key.valid() )
{
return false;
}
// First check the key against the min/max level limits, it they are set.
if ((_runtimeOptions->maxLevel().isSet() && key.getLOD() > _runtimeOptions->maxLevel().value()) ||
(_runtimeOptions->minLevel().isSet() && key.getLOD() < _runtimeOptions->minLevel().value()))
{
return false;
}
// Next, check against resolution limits (based on the source tile size).
if (_runtimeOptions->minResolution().isSet() ||
_runtimeOptions->maxResolution().isSet())
{
const Profile* profile = getProfile();
if ( profile )
{
// calculate the resolution in the layer's profile, which can
// be different that the key's profile.
double resKey = key.getExtent().width() / (double)getTileSize();
double resLayer = key.getProfile()->getSRS()->transformUnits(resKey, profile->getSRS());
if (_runtimeOptions->maxResolution().isSet() &&
_runtimeOptions->maxResolution().value() > resLayer)
{
return false;
}
if (_runtimeOptions->minResolution().isSet() &&
_runtimeOptions->minResolution().value() < resLayer)
{
return false;
}
}
}
return true;
}
bool
TerrainLayer::isKeyValid(const TileKey& key) const
{
if (!key.valid())
return false;
// Check to see if an explicity max LOD is set. Do NOT compare against the minLevel,
// because we still need to create empty tiles until we get to the data. The ImageLayer
// will deal with this.
if ( _runtimeOptions->maxLevel().isSet() && key.getLOD() > _runtimeOptions->maxLevel().value() )
{
return false;
}
// Check to see if levels of detail based on resolution are set
const Profile* profile = getProfile();
if ( profile )
{
if ( !profile->isEquivalentTo( key.getProfile() ) )
{
OE_DEBUG << LC
<< "TerrainLayer::isKeyValid called with key of a different profile" << std::endl;
//return true;
}
if ( _runtimeOptions->maxResolution().isSet() )
{
double keyres = key.getExtent().width() / (double)getTileSize();
double keyresInLayerProfile = key.getProfile()->getSRS()->transformUnits(keyres, profile->getSRS());
if ( _runtimeOptions->maxResolution().isSet() && keyresInLayerProfile < _runtimeOptions->maxResolution().value() )
{
return false;
}
}
}
return true;
}
bool
ElevationPool::fetchTileFromMap(const TileKey& key, MapFrame& frame, Tile* tile)
{
tile->_loadTime = osg::Timer::instance()->tick();
osg::ref_ptr<osg::HeightField> hf = new osg::HeightField();
hf->allocate( _tileSize, _tileSize );
// Initialize the heightfield to nodata
hf->getFloatArray()->assign( hf->getFloatArray()->size(), NO_DATA_VALUE );
TileKey keyToUse = key;
while( !tile->_hf.valid() && keyToUse.valid() )
{
bool ok;
if (_layers.empty())
{
OE_TEST << LC << "Populating from FULL MAP (" << keyToUse.str() << ")\n";
ok = frame.populateHeightField(hf, keyToUse, false /*heightsAsHAE*/, 0L);
}
else
{
OE_TEST << LC << "Populating from layers (" << keyToUse.str() << ")\n";
ok = _layers.populateHeightFieldAndNormalMap(hf.get(), 0L, keyToUse, 0L, INTERP_BILINEAR, 0L);
}
if (ok)
{
tile->_hf = GeoHeightField( hf.get(), keyToUse.getExtent() );
tile->_bounds = keyToUse.getExtent().bounds();
}
else
{
keyToUse = keyToUse.createParentKey();
}
}
return tile->_hf.valid();
}
bool
ElevationLayerVector::populateHeightField(osg::HeightField* hf,
const TileKey& key,
const Profile* haeProfile,
ElevationInterpolation interpolation,
ProgressCallback* progress ) const
{
//osg::Timer_t startTime = osg::Timer::instance()->tick();
// heightfield must already exist.
if ( !hf )
return false;
// if the caller provided an "HAE map profile", he wants an HAE elevation grid even if
// the map profile has a vertical datum. This is the usual case when building the 3D
// terrain, for example. Construct a temporary key that doesn't have the vertical
// datum info and use that to query the elevation data.
TileKey keyToUse = key;
if ( haeProfile )
{
keyToUse = TileKey(key.getLOD(), key.getTileX(), key.getTileY(), haeProfile );
}
// Collect the valid layers for this tile.
LayerAndKeyVector contenders;
LayerAndKeyVector offsets;
// Track the number of layers that would return fallback data.
unsigned numFallbackLayers = 0;
// Check them in reverse order since the highest priority is last.
for(ElevationLayerVector::const_reverse_iterator i = this->rbegin(); i != this->rend(); ++i)
{
ElevationLayer* layer = i->get();
if ( layer->getEnabled() && layer->getVisible() )
{
// calculate the resolution-mapped key (adjusted for tile resolution differential).
TileKey mappedKey = keyToUse.mapResolution(
hf->getNumColumns(),
layer->getTileSize() );
bool useLayer = true;
TileKey bestKey( mappedKey );
// Is there a tilesource? If not we are cache-only and cannot reject the layer.
if ( layer->getTileSource() )
{
// Check whether the non-mapped key is valid according to the user's min/max level settings:
if ( !layer->isKeyInRange(key) )
{
useLayer = false;
}
// Find the "best available" mapped key from the tile source:
else
{
if ( layer->getTileSource()->getBestAvailableTileKey(mappedKey, bestKey) )
{
// If the bestKey is not the mappedKey, this layer is providing
// fallback data (data at a lower resolution than requested)
if ( mappedKey != bestKey )
{
numFallbackLayers++;
}
}
else
{
useLayer = false;
}
}
}
if ( useLayer )
{
if ( layer->isOffset() )
{
offsets.push_back( std::make_pair(layer, bestKey) );
}
else
{
contenders.push_back( std::make_pair(layer, bestKey) );
}
}
}
}
// nothing? bail out.
if ( contenders.empty() && offsets.empty() )
{
return false;
}
// if everything is fallback data, bail out.
if ( contenders.size() + offsets.size() == numFallbackLayers )
{
return false;
}
// Sample the layers into our target.
unsigned numColumns = hf->getNumColumns();
unsigned numRows = hf->getNumRows();
double xmin = key.getExtent().xMin();
double ymin = key.getExtent().yMin();
double dx = key.getExtent().width() / (double)(numColumns-1);
double dy = key.getExtent().height() / (double)(numRows-1);
// We will load the actual heightfields on demand. We might not need them all.
GeoHeightFieldVector heightFields(contenders.size());
GeoHeightFieldVector offsetFields(offsets.size());
std::vector<bool> heightFailed(contenders.size(), false);
std::vector<bool> offsetFailed(offsets.size(), false);
// The maximum number of heightfields to keep in this local cache
unsigned int maxHeightFields = 50;
unsigned numHeightFieldsInCache = 0;
//double fallBackTime = 0;
const SpatialReference* keySRS = keyToUse.getProfile()->getSRS();
bool realData = false;
//unsigned int numFallback = 0;
unsigned int total = numColumns * numRows;
unsigned int completed = 0;
for (unsigned c = 0; c < numColumns; ++c)
{
double x = xmin + (dx * (double)c);
for (unsigned r = 0; r < numRows; ++r)
{
double y = ymin + (dy * (double)r);
// Collect elevations from each layer as necessary.
bool resolved = false;
for(int i=0; i<contenders.size() && !resolved; ++i)
{
if ( heightFailed[i] )
continue;
ElevationLayer* layer = contenders[i].first.get();
GeoHeightField& layerHF = heightFields[i];
if ( !layerHF.valid() )
{
layerHF = layer->createHeightField(contenders[i].second, progress);
if ( !layerHF.valid() )
{
// This layer potentially has data or it wouldn't have ended up in the contendors list, so try falling back on the parent
TileKey parentKey = contenders[i].second.createParentKey();
while (!layerHF.valid() && parentKey.valid())
{
//numFallback++;
//osg::Timer_t fbStartTime = osg::Timer::instance()->tick();
GeoHeightField parentHF = layer->createHeightField(parentKey, progress);
//osg::Timer_t fbEndTime = osg::Timer::instance()->tick();
// Only penalize time wasted actually falling back.
//if (!parentHF.valid())
// {
// fallBackTime += osg::Timer::instance()->delta_m(fbStartTime, fbEndTime);
//}
if (parentHF.valid())
{
layerHF = parentHF;
break;
}
else
{
parentKey = parentKey.createParentKey();
}
}
if (!layerHF.valid())
{
heightFailed[i] = true;
continue;
}
}
else
{
numHeightFieldsInCache++;
}
}
// If we actually got a layer then we have real data
realData = true;
float elevation;
if (layerHF.getElevation(keySRS, x, y, interpolation, keySRS, elevation) &&
elevation != NO_DATA_VALUE)
{
resolved = true;
hf->setHeight(c, r, elevation);
}
// Clear the heightfield cache if we have too many heightfields in the cache.
if (numHeightFieldsInCache >= maxHeightFields)
{
//OE_NOTICE << "Clearing cache" << std::endl;
for (unsigned int k = 0; k < heightFields.size(); k++)
{
heightFields[k] = GeoHeightField::INVALID;
}
numHeightFieldsInCache = 0;
}
}
for(int i=offsets.size()-1; i>=0; --i)
{
if ( offsetFailed[i] )
continue;
GeoHeightField& layerHF = offsetFields[i];
if ( !layerHF.valid() )
{
ElevationLayer* offset = offsets[i].first.get();
layerHF = offset->createHeightField(offsets[i].second, progress);
if ( !layerHF.valid() )
{
offsetFailed[i] = true;
continue;
}
}
// If we actually got a layer then we have real data
realData = true;
float elevation = 0.0f;
if (layerHF.getElevation(keySRS, x, y, interpolation, keySRS, elevation) &&
elevation != NO_DATA_VALUE)
{
hf->getHeight(c, r) += elevation;
}
}
completed++;
//OE_NOTICE << "Completed " << completed << " of " << total << std::endl;
}
}
//osg::Timer_t endTime = osg::Timer::instance()->tick();
//double totalTime = osg::Timer::instance()->delta_m(startTime, endTime);
// double fallbackPercentage = fallBackTime / totalTime;
//if (fallBackTime > 0)
//{
// OE_NOTICE << "populateHeightField took " << totalTime << "ms fallbacktime=" << fallBackTime << "ms count=" << numFallback << " percentage=" << fallbackPercentage << std::endl;
//}
//else
//{
// OE_NOTICE << "populateHeightField took " << totalTime << "ms" << std::endl;
//}
// Return whether or not we actually read any real data
return realData;
}
bool
ElevationQuery::getElevationImpl(const osg::Vec3d& point,
const SpatialReference* pointSRS,
double& out_elevation,
double desiredResolution,
double* out_actualResolution)
{
if ( _maxDataLevel == 0 || _tileSize == 0 )
{
// this means there are no heightfields.
out_elevation = 0.0;
return true;
}
// this is the ideal LOD for the requested resolution:
unsigned int idealLevel = desiredResolution > 0.0
? _mapf.getProfile()->getLevelOfDetailForHorizResolution( desiredResolution, _tileSize )
: _maxDataLevel;
// based on the heightfields available, this is the best we can theorically do:
unsigned int bestAvailLevel = osg::minimum( idealLevel, _maxDataLevel );
if (_maxLevelOverride >= 0)
{
bestAvailLevel = osg::minimum(bestAvailLevel, (unsigned int)_maxLevelOverride);
}
// transform the input coords to map coords:
osg::Vec3d mapPoint = point;
if ( pointSRS && !pointSRS->isEquivalentTo( _mapf.getProfile()->getSRS() ) )
{
if ( !pointSRS->transform2D( point.x(), point.y(), _mapf.getProfile()->getSRS(), mapPoint.x(), mapPoint.y() ) )
{
OE_WARN << LC << "Fail: coord transform failed" << std::endl;
return false;
}
}
osg::ref_ptr<osg::HeightField> hf;
osg::ref_ptr<osgTerrain::TerrainTile> tile;
// get the tilekey corresponding to the tile we need:
TileKey key = _mapf.getProfile()->createTileKey( mapPoint.x(), mapPoint.y(), bestAvailLevel );
if ( !key.valid() )
{
OE_WARN << LC << "Fail: coords fall outside map" << std::endl;
return false;
}
// Check the tile cache. Note that the TileSource already likely has a MemCache
// attached to it. We employ a secondary cache here for a couple reasons. One, this
// cache will store not only the heightfield, but also the tesselated tile in the event
// that we're using GEOMETRIC mode. Second, since the call the getHeightField can
// fallback on a lower resolution, this cache will hold the final resolution heightfield
// instead of trying to fetch the higher resolution one each tiem.
TileCache::Record record = _tileCache.get( key );
if ( record.valid() )
tile = record.value().get();
// if we found it, make sure it has a heightfield in it:
if ( tile.valid() )
{
osgTerrain::HeightFieldLayer* layer = dynamic_cast<osgTerrain::HeightFieldLayer*>(tile->getElevationLayer());
if ( layer )
hf = layer->getHeightField();
if ( !hf.valid() )
tile = 0L;
}
// if we didn't find it (or it didn't have heightfield data), build it.
if ( !tile.valid() )
{
// generate the heightfield corresponding to the tile key, automatically falling back
// on lower resolution if necessary:
_mapf.getHeightField( key, true, hf, 0L, _interpolation );
// bail out if we could not make a heightfield a all.
if ( !hf.valid() )
{
OE_WARN << LC << "Unable to create heightfield for key " << key.str() << std::endl;
return false;
}
// All this stuff is requires for GEOMETRIC mode. An optimization would be to
// defer this so that PARAMETRIC mode doesn't waste time
GeoLocator* locator = GeoLocator::createForKey( key, _mapf.getMapInfo() );
tile = new osgTerrain::TerrainTile();
osgTerrain::HeightFieldLayer* layer = new osgTerrain::HeightFieldLayer( hf.get() );
layer->setLocator( locator );
tile->setElevationLayer( layer );
tile->setRequiresNormals( false );
tile->setTerrainTechnique( new osgTerrain::GeometryTechnique );
// store it in the local tile cache.
_tileCache.insert( key, tile.get() );
}
OE_DEBUG << LC << "LRU Cache, hit ratio = " << _tileCache.getStats()._hitRatio << std::endl;
// see what the actual resolution of the heightfield is.
if ( out_actualResolution )
*out_actualResolution = (double)hf->getXInterval();
// finally it's time to get a height value:
if ( _technique == TECHNIQUE_PARAMETRIC )
{
const GeoExtent& extent = key.getExtent();
double xInterval = extent.width() / (double)(hf->getNumColumns()-1);
double yInterval = extent.height() / (double)(hf->getNumRows()-1);
out_elevation = (double) HeightFieldUtils::getHeightAtLocation(
hf.get(), mapPoint.x(), mapPoint.y(), extent.xMin(), extent.yMin(), xInterval, yInterval );
return true;
}
else // ( _technique == TECHNIQUE_GEOMETRIC )
{
osg::Vec3d start, end, zero;
if ( _mapf.getMapInfo().isGeocentric() )
{
const SpatialReference* mapSRS = _mapf.getProfile()->getSRS();
mapSRS->transformToECEF( osg::Vec3d(mapPoint.y(), mapPoint.x(), 50000.0), start );
mapSRS->transformToECEF( osg::Vec3d(mapPoint.y(), mapPoint.x(), -50000.0), end );
mapSRS->transformToECEF( osg::Vec3d(mapPoint.y(), mapPoint.x(), 0.0), zero );
}
else // PROJECTED
{
start.set( mapPoint.x(), mapPoint.y(), 50000.0 );
end.set ( mapPoint.x(), mapPoint.y(), -50000.0 );
zero.set ( mapPoint.x(), mapPoint.y(), 0.0 );
}
osgUtil::LineSegmentIntersector* i = new osgUtil::LineSegmentIntersector( start, end );
osgUtil::IntersectionVisitor iv;
iv.setIntersector( i );
tile->accept( iv );
osgUtil::LineSegmentIntersector::Intersections& results = i->getIntersections();
if ( !results.empty() )
{
const osgUtil::LineSegmentIntersector::Intersection& result = *results.begin();
osg::Vec3d isectPoint = result.getWorldIntersectPoint();
out_elevation = (isectPoint-end).length2() > (zero-end).length2()
? (isectPoint-zero).length()
: -(isectPoint-zero).length();
return true;
}
OE_DEBUG << LC << "No intersection" << std::endl;
return false;
}
}
osg::Image*
CompositeTileSource::createImage(const TileKey& key,
ProgressCallback* progress )
{
ImageMixVector images;
images.reserve(_imageLayers.size());
// Try to get an image from each of the layers for the given key.
for (ImageLayerVector::const_iterator itr = _imageLayers.begin(); itr != _imageLayers.end(); ++itr)
{
ImageLayer* layer = itr->get();
ImageInfo imageInfo;
imageInfo.dataInExtents = layer->getTileSource()->hasDataInExtent( key.getExtent() );
imageInfo.opacity = layer->getOpacity();
if (imageInfo.dataInExtents)
{
GeoImage image = layer->createImage(key, progress);
if (image.valid())
{
imageInfo.image = image.getImage();
}
// If the progress got cancelled or it needs a retry then return NULL to prevent this tile from being built and cached with incomplete or partial data.
if (progress && (progress->isCanceled() || progress->needsRetry()))
{
OE_DEBUG << LC << " createImage was cancelled or needs retry for " << key.str() << std::endl;
return 0L;
}
}
images.push_back(imageInfo);
}
// Determine the output texture size to use based on the image that were creatd.
unsigned numValidImages = 0;
osg::Vec2s textureSize;
for (unsigned int i = 0; i < images.size(); i++)
{
ImageInfo& info = images[i];
if (info.image.valid())
{
if (numValidImages == 0)
{
textureSize.set( info.image->s(), info.image->t());
}
numValidImages++;
}
}
// Create fallback images if we have some valid data but not for all the layers
if (numValidImages > 0 && numValidImages < images.size())
{
for (unsigned int i = 0; i < images.size(); i++)
{
ImageInfo& info = images[i];
ImageLayer* layer = _imageLayers[i].get();
if (!info.image.valid() && info.dataInExtents)
{
TileKey parentKey = key.createParentKey();
GeoImage image;
while (!image.valid() && parentKey.valid())
{
image = layer->createImage(parentKey, progress);
if (image.valid())
{
break;
}
// If the progress got cancelled or it needs a retry then return NULL to prevent this tile from being built and cached with incomplete or partial data.
if (progress && (progress->isCanceled() || progress->needsRetry()))
{
OE_DEBUG << LC << " createImage was cancelled or needs retry for " << key.str() << std::endl;
return 0L;
}
parentKey = parentKey.createParentKey();
}
if (image.valid())
{
// TODO: Bilinear options?
bool bilinear = layer->isCoverage() ? false : true;
GeoImage cropped = image.crop( key.getExtent(), true, textureSize.x(), textureSize.y(), bilinear);
info.image = cropped.getImage();
}
}
}
}
// Now finally create the output image.
//Recompute the number of valid images
numValidImages = 0;
for (unsigned int i = 0; i < images.size(); i++)
{
ImageInfo& info = images[i];
if (info.image.valid()) numValidImages++;
}
if ( progress && progress->isCanceled() )
{
return 0L;
}
else if ( numValidImages == 0 )
{
return 0L;
}
else if ( numValidImages == 1 )
{
//We only have one valid image, so just return it and don't bother with compositing
for (unsigned int i = 0; i < images.size(); i++)
{
ImageInfo& info = images[i];
if (info.image.valid())
return info.image.release();
}
return 0L;
}
else
{
osg::Image* result = 0;
for (unsigned int i = 0; i < images.size(); i++)
{
ImageInfo& imageInfo = images[i];
if (!result)
{
if (imageInfo.image.valid())
{
result = new osg::Image( *imageInfo.image.get());
}
}
else
{
if (imageInfo.image.valid())
{
ImageUtils::mix( result, imageInfo.image.get(), imageInfo.opacity );
}
}
}
return result;
}
}
osg::Image*
CompositeTileSource::createImage(const TileKey& key,
ProgressCallback* progress )
{
ImageMixVector images;
images.reserve( _options._components.size() );
for(CompositeTileSourceOptions::ComponentVector::const_iterator i = _options._components.begin();
i != _options._components.end();
++i )
{
if ( progress && progress->isCanceled() )
return 0L;
ImageInfo imageInfo;
imageInfo.dataInExtents = false;
TileSource* source = i->_tileSourceInstance.get();
if ( source )
{
//TODO: This duplicates code in ImageLayer::isKeyValid. Maybe should move that to TileSource::isKeyValid instead
int minLevel = 0;
int maxLevel = INT_MAX;
if (i->_imageLayerOptions->minLevel().isSet())
{
minLevel = i->_imageLayerOptions->minLevel().value();
}
else if (i->_imageLayerOptions->minResolution().isSet())
{
minLevel = source->getProfile()->getLevelOfDetailForHorizResolution(
i->_imageLayerOptions->minResolution().value(),
source->getPixelsPerTile());
}
if (i->_imageLayerOptions->maxLevel().isSet())
{
maxLevel = i->_imageLayerOptions->maxLevel().value();
}
else if (i->_imageLayerOptions->maxResolution().isSet())
{
maxLevel = source->getProfile()->getLevelOfDetailForHorizResolution(
i->_imageLayerOptions->maxResolution().value(),
source->getPixelsPerTile());
}
// check that this source is within the level bounds:
if (minLevel > (int)key.getLevelOfDetail() ||
maxLevel < (int)key.getLevelOfDetail() )
{
continue;
}
//Only try to get data if the source actually has data
if (source->hasDataInExtent( key.getExtent() ) )
{
//We have data within these extents
imageInfo.dataInExtents = true;
if ( !source->getBlacklist()->contains( key.getTileId() ) )
{
osg::ref_ptr< ImageLayerPreCacheOperation > preCacheOp;
if ( i->_imageLayerOptions.isSet() )
{
preCacheOp = new ImageLayerPreCacheOperation();
preCacheOp->_processor.init( i->_imageLayerOptions.value(), _dbOptions.get(), true );
}
imageInfo.image = source->createImage( key, preCacheOp.get(), progress );
imageInfo.opacity = 1.0f;
//If the image is not valid and the progress was not cancelled, blacklist
if (!imageInfo.image.valid() && (!progress || !progress->isCanceled()))
{
//Add the tile to the blacklist
OE_DEBUG << LC << "Adding tile " << key.str() << " to the blacklist" << std::endl;
source->getBlacklist()->add( key.getTileId() );
}
imageInfo.opacity = i->_imageLayerOptions.isSet() ? i->_imageLayerOptions->opacity().value() : 1.0f;
}
}
else
{
OE_DEBUG << LC << "Source has no data at " << key.str() << std::endl;
}
}
//Add the ImageInfo to the list
images.push_back( imageInfo );
}
unsigned numValidImages = 0;
osg::Vec2s textureSize;
for (unsigned int i = 0; i < images.size(); i++)
{
ImageInfo& info = images[i];
if (info.image.valid())
{
if (numValidImages == 0)
{
textureSize.set( info.image->s(), info.image->t());
}
numValidImages++;
}
}
//Try to fallback on any empty images if we have some valid images but not valid images for ALL layers
if (numValidImages > 0 && numValidImages < images.size())
{
for (unsigned int i = 0; i < images.size(); i++)
{
ImageInfo& info = images[i];
if (!info.image.valid() && info.dataInExtents)
{
TileKey parentKey = key.createParentKey();
TileSource* source = _options._components[i]._tileSourceInstance;
if (source)
{
osg::ref_ptr< ImageLayerPreCacheOperation > preCacheOp;
if ( _options._components[i]._imageLayerOptions.isSet() )
{
preCacheOp = new ImageLayerPreCacheOperation();
preCacheOp->_processor.init( _options._components[i]._imageLayerOptions.value(), _dbOptions.get(), true );
}
osg::ref_ptr< osg::Image > image;
while (!image.valid() && parentKey.valid())
{
image = source->createImage( parentKey, preCacheOp.get(), progress );
if (image.valid())
{
break;
}
parentKey = parentKey.createParentKey();
}
if (image.valid())
{
//We got an image, but now we need to crop it to match the incoming key's extents
GeoImage geoImage( image.get(), parentKey.getExtent());
GeoImage cropped = geoImage.crop( key.getExtent(), true, textureSize.x(), textureSize.y(), *source->_options.bilinearReprojection());
image = cropped.getImage();
}
info.image = image.get();
}
}
}
}
//Recompute the number of valid images
numValidImages = 0;
for (unsigned int i = 0; i < images.size(); i++)
{
ImageInfo& info = images[i];
if (info.image.valid()) numValidImages++;
}
if ( progress && progress->isCanceled() )
{
return 0L;
}
else if ( numValidImages == 0 )
{
return 0L;
}
else if ( numValidImages == 1 )
{
//We only have one valid image, so just return it and don't bother with compositing
for (unsigned int i = 0; i < images.size(); i++)
{
ImageInfo& info = images[i];
if (info.image.valid())
return info.image.release();
}
return 0L;
}
else
{
osg::Image* result = 0;
for (unsigned int i = 0; i < images.size(); i++)
{
ImageInfo& imageInfo = images[i];
if (!result)
{
if (imageInfo.image.valid())
{
result = new osg::Image( *imageInfo.image.get());
}
}
else
{
if (imageInfo.image.valid())
{
ImageUtils::mix( result, imageInfo.image, imageInfo.opacity );
}
}
}
return result;
}
}
void
TileModelFactory::buildElevation(const TileKey& key,
const MapFrame& frame,
bool accumulate,
bool buildTexture,
TileModel* model,
ProgressCallback* progress)
{
const MapInfo& mapInfo = frame.getMapInfo();
const osgEarth::ElevationInterpolation& interp =
frame.getMapOptions().elevationInterpolation().get();
// Request a heightfield from the map, falling back on lower resolution tiles
// if necessary (fallback=true)
osg::ref_ptr<osg::HeightField> hf;
bool isFallback = false;
// look up the parent's heightfield to use as a template
osg::ref_ptr<osg::HeightField> parentHF;
TileKey parentKey = key.createParentKey();
if ( accumulate )
{
osg::ref_ptr<TileNode> parentNode;
if (_liveTiles->get(parentKey, parentNode))
{
parentHF = parentNode->getTileModel()->_elevationData.getHeightField();
if ( _debug && key.getLOD() > 0 && !parentHF.valid() )
{
OE_NOTICE << LC << "Could not find a parent tile HF for " << key.str() << "\n";
}
}
}
// Make a new heightfield:
if (_meshHFCache->getOrCreateHeightField(frame, key, parentHF.get(), hf, isFallback, SAMPLE_FIRST_VALID, interp, progress))
{
model->_elevationData = TileModel::ElevationData(
hf,
GeoLocator::createForKey( key, mapInfo ),
isFallback );
// Edge normalization: requires adjacency information
if ( _terrainOptions.normalizeEdges() == true )
{
for( int x=-1; x<=1; x++ )
{
for( int y=-1; y<=1; y++ )
{
if ( x != 0 || y != 0 )
{
TileKey neighborKey = key.createNeighborKey(x, y);
if ( neighborKey.valid() )
{
osg::ref_ptr<osg::HeightField> neighborParentHF;
if ( accumulate )
{
TileKey neighborParentKey = neighborKey.createParentKey();
if (neighborParentKey == parentKey)
{
neighborParentHF = parentHF;
}
else
{
osg::ref_ptr<TileNode> neighborParentNode;
if (_liveTiles->get(neighborParentKey, neighborParentNode))
{
neighborParentHF = neighborParentNode->getTileModel()->_elevationData.getHeightField();
}
}
}
// only pull the tile if we have a valid parent HF for it -- otherwise
// you might get a flat tile when upsampling data.
if ( neighborParentHF.valid() )
{
osg::ref_ptr<osg::HeightField> hf;
if (_meshHFCache->getOrCreateHeightField(frame, neighborKey, neighborParentHF.get(), hf, isFallback, SAMPLE_FIRST_VALID, interp, progress) )
{
model->_elevationData.setNeighbor( x, y, hf.get() );
}
}
}
}
}
}
// parent too.
if ( parentHF.valid() )
{
model->_elevationData.setParent( parentHF.get() );
}
}
if ( buildTexture )
{
model->generateElevationTexture();
}
}
}
bool
ElevationLayerVector::populateHeightFieldAndNormalMap(osg::HeightField* hf,
NormalMap* normalMap,
const TileKey& key,
const Profile* haeProfile,
ElevationInterpolation interpolation,
ProgressCallback* progress ) const
{
// heightfield must already exist.
if ( !hf )
return false;
METRIC_SCOPED("ElevationLayer.populateHeightField");
// if the caller provided an "HAE map profile", he wants an HAE elevation grid even if
// the map profile has a vertical datum. This is the usual case when building the 3D
// terrain, for example. Construct a temporary key that doesn't have the vertical
// datum info and use that to query the elevation data.
TileKey keyToUse = key;
if ( haeProfile )
{
keyToUse = TileKey(key.getLOD(), key.getTileX(), key.getTileY(), haeProfile );
}
// Collect the valid layers for this tile.
LayerDataVector contenders;
LayerDataVector offsets;
#ifdef ANALYZE
struct LayerAnalysis {
LayerAnalysis() : samples(0), used(false), failed(false), fallback(false), actualKeyValid(true) { }
int samples; bool used; bool failed; bool fallback; bool actualKeyValid; std::string message;
};
std::map<ElevationLayer*, LayerAnalysis> layerAnalysis;
#endif
// Track the number of layers that would return fallback data.
unsigned numFallbackLayers = 0;
// Check them in reverse order since the highest priority is last.
for (int i = size()-1; i>=0; --i)
//for(ElevationLayerVector::const_reverse_iterator i = this->rbegin(); i != this->rend(); ++i)
{
ElevationLayer* layer = (*this)[i].get(); //i->get();
if ( layer->getEnabled() && layer->getVisible() )
{
// calculate the resolution-mapped key (adjusted for tile resolution differential).
TileKey mappedKey = keyToUse.mapResolution(
hf->getNumColumns(),
layer->getTileSize() );
bool useLayer = true;
TileKey bestKey( mappedKey );
// Check whether the non-mapped key is valid according to the user's min/max level settings:
if ( !layer->isKeyInLegalRange(key) )
{
useLayer = false;
}
// Find the "best available" mapped key from the tile source:
else
{
bestKey = layer->getBestAvailableTileKey(mappedKey);
if (bestKey.valid())
{
// If the bestKey is not the mappedKey, this layer is providing
// fallback data (data at a lower resolution than requested)
if ( mappedKey != bestKey )
{
numFallbackLayers++;
}
}
else
{
useLayer = false;
}
}
if ( useLayer )
{
if ( layer->isOffset() )
{
offsets.push_back(LayerData());
LayerData& ld = offsets.back();
ld.layer = layer;
ld.key = bestKey;
ld.index = i;
}
else
{
contenders.push_back(LayerData());
LayerData& ld = contenders.back();
ld.layer = layer;
ld.key = bestKey;
ld.index = i;
}
#ifdef ANALYZE
layerAnalysis[layer].used = true;
#endif
}
}
}
// nothing? bail out.
if ( contenders.empty() && offsets.empty() )
{
return false;
}
// if everything is fallback data, bail out.
if ( contenders.size() + offsets.size() == numFallbackLayers )
{
return false;
}
// Sample the layers into our target.
unsigned numColumns = hf->getNumColumns();
unsigned numRows = hf->getNumRows();
double xmin = key.getExtent().xMin();
double ymin = key.getExtent().yMin();
double dx = key.getExtent().width() / (double)(numColumns-1);
double dy = key.getExtent().height() / (double)(numRows-1);
// We will load the actual heightfields on demand. We might not need them all.
GeoHeightFieldVector heightFields(contenders.size());
GeoHeightFieldVector offsetFields(offsets.size());
std::vector<bool> heightFallback(contenders.size(), false);
std::vector<bool> heightFailed(contenders.size(), false);
std::vector<bool> offsetFailed(offsets.size(), false);
// The maximum number of heightfields to keep in this local cache
const unsigned maxHeightFields = 50;
unsigned numHeightFieldsInCache = 0;
const SpatialReference* keySRS = keyToUse.getProfile()->getSRS();
bool realData = false;
unsigned int total = numColumns * numRows;
// query resolution interval (x, y) of each sample.
osg::ref_ptr<osg::ShortArray> deltaLOD = new osg::ShortArray(total);
int nodataCount = 0;
TileKey scratchKey; // Storage if a new key needs to be constructed
bool requiresResample = true;
// If we only have a single contender layer, and the tile is the same size as the requested
// heightfield then we just use it directly and avoid having to resample it
if (contenders.size() == 1 && offsets.empty())
{
ElevationLayer* layer = contenders[0].layer.get();
TileKey& contenderKey = contenders[0].key;
GeoHeightField layerHF = layer->createHeightField(contenderKey, 0);
if (layerHF.valid())
{
if (layerHF.getHeightField()->getNumColumns() == hf->getNumColumns() &&
layerHF.getHeightField()->getNumRows() == hf->getNumRows())
{
requiresResample = false;
memcpy(hf->getFloatArray()->asVector().data(),
layerHF.getHeightField()->getFloatArray()->asVector().data(),
sizeof(float) * hf->getFloatArray()->size()
);
deltaLOD->resize(hf->getFloatArray()->size(), 0);
realData = true;
}
}
}
// If we need to mosaic multiple layers or resample it to a new output tilesize go through a resampling loop.
if (requiresResample)
{
for (unsigned c = 0; c < numColumns; ++c)
{
double x = xmin + (dx * (double)c);
// periodically check for cancelation
if (progress && progress->isCanceled())
{
return false;
}
for (unsigned r = 0; r < numRows; ++r)
{
double y = ymin + (dy * (double)r);
// Collect elevations from each layer as necessary.
int resolvedIndex = -1;
osg::Vec3 normal_sum(0, 0, 0);
for (int i = 0; i < contenders.size() && resolvedIndex < 0; ++i)
{
ElevationLayer* layer = contenders[i].layer.get();
TileKey& contenderKey = contenders[i].key;
int index = contenders[i].index;
if (heightFailed[i])
continue;
TileKey* actualKey = &contenderKey;
GeoHeightField& layerHF = heightFields[i];
if (!layerHF.valid())
{
// We couldn't get the heightfield from the cache, so try to create it.
// We also fallback on parent layers to make sure that we have data at the location even if it's fallback.
while (!layerHF.valid() && actualKey->valid() && layer->isKeyInLegalRange(*actualKey))
{
layerHF = layer->createHeightField(*actualKey, progress);
if (!layerHF.valid())
{
if (actualKey != &scratchKey)
{
scratchKey = *actualKey;
actualKey = &scratchKey;
}
*actualKey = actualKey->createParentKey();
}
}
// Mark this layer as fallback if necessary.
if (layerHF.valid())
{
heightFallback[i] = (*actualKey != contenderKey); // actualKey != contenders[i].second;
numHeightFieldsInCache++;
}
else
{
heightFailed[i] = true;
#ifdef ANALYZE
layerAnalysis[layer].failed = true;
layerAnalysis[layer].actualKeyValid = actualKey->valid();
if (progress) layerAnalysis[layer].message = progress->message();
#endif
continue;
}
}
if (layerHF.valid())
{
bool isFallback = heightFallback[i];
#ifdef ANALYZE
layerAnalysis[layer].fallback = isFallback;
#endif
// We only have real data if this is not a fallback heightfield.
if (!isFallback)
{
realData = true;
}
float elevation;
if (layerHF.getElevation(keySRS, x, y, interpolation, keySRS, elevation))
{
if (elevation != NO_DATA_VALUE)
{
// remember the index so we can only apply offset layers that
// sit on TOP of this layer.
resolvedIndex = index;
hf->setHeight(c, r, elevation);
#ifdef ANALYZE
layerAnalysis[layer].samples++;
#endif
if (deltaLOD)
{
(*deltaLOD)[r*numColumns + c] = key.getLOD() - actualKey->getLOD();
}
}
else
{
++nodataCount;
}
}
}
// Clear the heightfield cache if we have too many heightfields in the cache.
if (numHeightFieldsInCache >= maxHeightFields)
{
//OE_NOTICE << "Clearing cache" << std::endl;
for (unsigned int k = 0; k < heightFields.size(); k++)
{
heightFields[k] = GeoHeightField::INVALID;
heightFallback[k] = false;
}
numHeightFieldsInCache = 0;
}
}
for (int i = offsets.size() - 1; i >= 0; --i)
{
// Only apply an offset layer if it sits on top of the resolved layer
// (or if there was no resolved layer).
if (resolvedIndex >= 0 && offsets[i].index < resolvedIndex)
continue;
TileKey &contenderKey = offsets[i].key;
if (offsetFailed[i] == true)
continue;
GeoHeightField& layerHF = offsetFields[i];
if (!layerHF.valid())
{
ElevationLayer* offset = offsets[i].layer.get();
layerHF = offset->createHeightField(contenderKey, progress);
if (!layerHF.valid())
{
offsetFailed[i] = true;
continue;
}
}
// If we actually got a layer then we have real data
realData = true;
float elevation = 0.0f;
if (layerHF.getElevation(keySRS, x, y, interpolation, keySRS, elevation) &&
elevation != NO_DATA_VALUE)
{
hf->getHeight(c, r) += elevation;
// Update the resolution tracker to account for the offset. Sadly this
// will wipe out the resolution of the actual data, and might result in
// normal faceting. See the comments on "createNormalMap" for more info
if (deltaLOD)
{
(*deltaLOD)[r*numColumns + c] = key.getLOD() - contenderKey.getLOD();
}
}
}
}
}
}
if (normalMap)
{
// periodically check for cancelation
if (progress && progress->isCanceled())
{
return false;
}
createNormalMap(key.getExtent(), hf, deltaLOD.get(), normalMap);
}
#ifdef ANALYZE
{
static Threading::Mutex m;
Threading::ScopedMutexLock lock(m);
std::cout << key.str() << ": ";
for (std::map<ElevationLayer*, LayerAnalysis>::const_iterator i = layerAnalysis.begin();
i != layerAnalysis.end(); ++i)
{
std::cout << i->first->getName()
<< " used=" << i->second.used
<< " failed=" << i->second.failed
<< " akv=" << i->second.actualKeyValid
<< " fallback=" << i->second.fallback
<< " samples=" << i->second.samples
<< " msg=" << i->second.message
<< "; ";
}
std::cout << std::endl;
}
#endif
if (progress && progress->isCanceled())
{
return false;
}
// Return whether or not we actually read any real data
return realData;
}
GeoImage
ImageLayer::assembleImageFromTileSource(const TileKey& key,
ProgressCallback* progress)
{
GeoImage mosaicedImage, result;
// Scale the extent if necessary to apply an "edge buffer"
GeoExtent ext = key.getExtent();
if ( _runtimeOptions.edgeBufferRatio().isSet() )
{
double ratio = _runtimeOptions.edgeBufferRatio().get();
ext.scale(ratio, ratio);
}
// Get a set of layer tiles that intersect the requested extent.
std::vector<TileKey> intersectingKeys;
getProfile()->getIntersectingTiles( key, intersectingKeys );
if ( intersectingKeys.size() > 0 )
{
double dst_minx, dst_miny, dst_maxx, dst_maxy;
key.getExtent().getBounds(dst_minx, dst_miny, dst_maxx, dst_maxy);
// if we find at least one "real" tile in the mosaic, then the whole result tile is
// "real" (i.e. not a fallback tile)
bool retry = false;
ImageMosaic mosaic;
// keep track of failed tiles.
std::vector<TileKey> failedKeys;
for( std::vector<TileKey>::iterator k = intersectingKeys.begin(); k != intersectingKeys.end(); ++k )
{
GeoImage image = createImageFromTileSource( *k, progress );
if ( image.valid() )
{
if ( !isCoverage() )
{
ImageUtils::fixInternalFormat(image.getImage());
// Make sure all images in mosaic are based on "RGBA - unsigned byte" pixels.
// This is not the smarter choice (in some case RGB would be sufficient) but
// it ensure consistency between all images / layers.
//
// The main drawback is probably the CPU memory foot-print which would be reduced by allocating RGB instead of RGBA images.
// On GPU side, this should not change anything because of data alignements : often RGB and RGBA textures have the same memory footprint
//
if ( (image.getImage()->getDataType() != GL_UNSIGNED_BYTE)
|| (image.getImage()->getPixelFormat() != GL_RGBA) )
{
osg::ref_ptr<osg::Image> convertedImg = ImageUtils::convertToRGBA8(image.getImage());
if (convertedImg.valid())
{
image = GeoImage(convertedImg, image.getExtent());
}
}
}
mosaic.getImages().push_back( TileImage(image.getImage(), *k) );
}
else
{
// the tile source did not return a tile, so make a note of it.
failedKeys.push_back( *k );
if (progress && (progress->isCanceled() || progress->needsRetry()))
{
retry = true;
break;
}
}
}
if ( mosaic.getImages().empty() || retry )
{
// if we didn't get any data, fail.
OE_DEBUG << LC << "Couldn't create image for ImageMosaic " << std::endl;
return GeoImage::INVALID;
}
// We got at least one good tile, so go through the bad ones and try to fall back on
// lower resolution data to fill in the gaps. The entire mosaic must be populated or
// this qualifies as a bad tile.
for(std::vector<TileKey>::iterator k = failedKeys.begin(); k != failedKeys.end(); ++k)
{
GeoImage image;
for(TileKey parentKey = k->createParentKey();
parentKey.valid() && !image.valid();
parentKey = parentKey.createParentKey())
{
image = createImageFromTileSource( parentKey, progress );
if ( image.valid() )
{
GeoImage cropped;
if ( !isCoverage() )
{
ImageUtils::fixInternalFormat(image.getImage());
if ( (image.getImage()->getDataType() != GL_UNSIGNED_BYTE)
|| (image.getImage()->getPixelFormat() != GL_RGBA) )
{
osg::ref_ptr<osg::Image> convertedImg = ImageUtils::convertToRGBA8(image.getImage());
if (convertedImg.valid())
{
image = GeoImage(convertedImg, image.getExtent());
}
}
cropped = image.crop( k->getExtent(), false, image.getImage()->s(), image.getImage()->t() );
}
else
{
// TODO: may not work.... test; tilekey extent will <> cropped extent
cropped = image.crop( k->getExtent(), true, image.getImage()->s(), image.getImage()->t(), false );
}
// and queue it.
mosaic.getImages().push_back( TileImage(cropped.getImage(), *k) );
}
}
if ( !image.valid() )
{
// a tile completely failed, even with fallback. Eject.
OE_DEBUG << LC << "Couldn't fallback on tiles for ImageMosaic" << std::endl;
// let it go. The empty areas will be filled with alpha by ImageMosaic.
}
}
// all set. Mosaic all the images together.
double rxmin, rymin, rxmax, rymax;
mosaic.getExtents( rxmin, rymin, rxmax, rymax );
mosaicedImage = GeoImage(
mosaic.createImage(),
GeoExtent( getProfile()->getSRS(), rxmin, rymin, rxmax, rymax ) );
}
else
{
OE_DEBUG << LC << "assembleImageFromTileSource: no intersections (" << key.str() << ")" << std::endl;
}
// Final step: transform the mosaic into the requesting key's extent.
if ( mosaicedImage.valid() )
{
// GeoImage::reproject() will automatically crop the image to the correct extents.
// so there is no need to crop after reprojection. Also note that if the SRS's are the
// same (even though extents are different), then this operation is technically not a
// reprojection but merely a resampling.
result = mosaicedImage.reproject(
key.getProfile()->getSRS(),
&key.getExtent(),
*_runtimeOptions.reprojectedTileSize(),
*_runtimeOptions.reprojectedTileSize(),
*_runtimeOptions.driver()->bilinearReprojection() );
}
// Process images with full alpha to properly support MP blending.
if ( result.valid() && *_runtimeOptions.featherPixels() && !isCoverage() )
{
ImageUtils::featherAlphaRegions( result.getImage() );
}
return result;
}
GeoImage
ImageLayer::createImageFromTileSource(const TileKey& key,
ProgressCallback* progress,
bool forceFallback,
bool& out_isFallback)
{
// Results:
//
// * return an osg::Image matching the key extent is all goes well;
//
// * return NULL to indicate that the key exceeds the maximum LOD of the source data,
// and that the engine may need to generate a "fallback" tile if necessary;
//
// deprecated:
// * return an "empty image" if the LOD is valid BUT the key does not intersect the
// source's data extents.
out_isFallback = false;
TileSource* source = getTileSource();
if ( !source )
return GeoImage::INVALID;
// If the profiles are different, use a compositing method to assemble the tile.
if ( !key.getProfile()->isEquivalentTo( getProfile() ) )
{
return assembleImageFromTileSource( key, progress, out_isFallback );
}
// Good to go, ask the tile source for an image:
osg::ref_ptr<TileSource::ImageOperation> op = _preCacheOp;
osg::ref_ptr<osg::Image> result;
if ( forceFallback )
{
// check if the tile source has any data coverage for the requested key.
// the LOD is ignore here and checked later
if ( !source->hasDataInExtent( key.getExtent() ) )
{
OE_DEBUG << LC << "createImageFromTileSource: hasDataInExtent(" << key.str() << ") == false" << std::endl;
return GeoImage::INVALID;
}
TileKey finalKey = key;
while( !result.valid() && finalKey.valid() )
{
if ( !source->getBlacklist()->contains( finalKey.getTileId() ) &&
source->hasDataForFallback(finalKey))
{
result = source->createImage( finalKey, op.get(), progress );
if ( result.valid() )
{
if ( finalKey.getLevelOfDetail() != key.getLevelOfDetail() )
{
// crop the fallback image to match the input key, and ensure that it remains the
// same pixel size; because chances are if we're requesting a fallback that we're
// planning to mosaic it later, and the mosaicer requires same-size images.
GeoImage raw( result.get(), finalKey.getExtent() );
GeoImage cropped = raw.crop( key.getExtent(), true, raw.getImage()->s(), raw.getImage()->t(), *_runtimeOptions.driver()->bilinearReprojection() );
result = cropped.takeImage();
}
}
}
if ( !result.valid() )
{
finalKey = finalKey.createParentKey();
out_isFallback = true;
}
}
if ( !result.valid() )
{
result = 0L;
//result = _emptyImage.get();
finalKey = key;
}
}
else
{
// Fail is the image is blacklisted.
if ( source->getBlacklist()->contains( key.getTileId() ) )
{
OE_DEBUG << LC << "createImageFromTileSource: blacklisted(" << key.str() << ")" << std::endl;
return GeoImage::INVALID;
}
if ( !source->hasData( key ) )
{
OE_DEBUG << LC << "createImageFromTileSource: hasData(" << key.str() << ") == false" << std::endl;
return GeoImage::INVALID;
}
result = source->createImage( key, op.get(), progress );
}
// Process images with full alpha to properly support MP blending.
if ( result != 0L && *_runtimeOptions.featherPixels())
{
ImageUtils::featherAlphaRegions( result.get() );
}
// If image creation failed (but was not intentionally canceled),
// blacklist this tile for future requests.
if ( result == 0L && (!progress || !progress->isCanceled()) )
{
source->getBlacklist()->add( key.getTileId() );
}
return GeoImage(result.get(), key.getExtent());
}
void CacheSeed::seed( Map* map )
{
if ( !map->getCache() )
{
OE_WARN << LC << "Warning: No cache defined; aborting." << std::endl;
return;
}
std::vector<TileKey> keys;
map->getProfile()->getRootKeys(keys);
//Add the map's entire extent if we don't have one specified.
if (_extents.empty())
{
addExtent( map->getProfile()->getExtent() );
}
bool hasCaches = false;
int src_min_level = INT_MAX;
unsigned int src_max_level = 0;
MapFrame mapf( map, Map::TERRAIN_LAYERS, "CacheSeed::seed" );
//Assumes the the TileSource will perform the caching for us when we call createImage
for( ImageLayerVector::const_iterator i = mapf.imageLayers().begin(); i != mapf.imageLayers().end(); i++ )
{
ImageLayer* layer = i->get();
TileSource* src = layer->getTileSource();
const ImageLayerOptions& opt = layer->getImageLayerOptions();
if ( layer->isCacheOnly() )
{
OE_WARN << LC << "Warning: Layer \"" << layer->getName() << "\" is set to cache-only; skipping." << std::endl;
}
else if ( !src )
{
OE_WARN << "Warning: Layer \"" << layer->getName() << "\" could not create TileSource; skipping." << std::endl;
}
//else if ( src->getCachePolicyHint(0L) == CachePolicy::NO_CACHE )
//{
// OE_WARN << LC << "Warning: Layer \"" << layer->getName() << "\" does not support seeding; skipping." << std::endl;
//}
else if ( !layer->getCache() )
{
OE_WARN << LC << "Notice: Layer \"" << layer->getName() << "\" has no cache defined; skipping." << std::endl;
}
else
{
hasCaches = true;
if (opt.minLevel().isSet() && (int)opt.minLevel().get() < src_min_level)
src_min_level = opt.minLevel().get();
if (opt.maxLevel().isSet() && opt.maxLevel().get() > src_max_level)
src_max_level = opt.maxLevel().get();
}
}
for( ElevationLayerVector::const_iterator i = mapf.elevationLayers().begin(); i != mapf.elevationLayers().end(); i++ )
{
ElevationLayer* layer = i->get();
TileSource* src = layer->getTileSource();
const ElevationLayerOptions& opt = layer->getElevationLayerOptions();
if ( layer->isCacheOnly() )
{
OE_WARN << LC << "Warning: Layer \"" << layer->getName() << "\" is set to cache-only; skipping." << std::endl;
}
else if (!src)
{
OE_WARN << "Warning: Layer \"" << layer->getName() << "\" could not create TileSource; skipping." << std::endl;
}
//else if ( src->getCachePolicyHint(0L) == CachePolicy::NO_CACHE )
//{
// OE_WARN << LC << "Warning: Layer \"" << layer->getName() << "\" does not support seeding; skipping." << std::endl;
//}
else if ( !layer->getCache() )
{
OE_WARN << LC << "Notice: Layer \"" << layer->getName() << "\" has no cache defined; skipping." << std::endl;
}
else
{
hasCaches = true;
if (opt.minLevel().isSet() && (int)opt.minLevel().get() < src_min_level)
src_min_level = opt.minLevel().get();
if (opt.maxLevel().isSet() && opt.maxLevel().get() > src_max_level)
src_max_level = opt.maxLevel().get();
}
}
if ( !hasCaches )
{
OE_WARN << LC << "There are either no caches defined in the map, or no sources to cache; aborting." << std::endl;
return;
}
if ( src_max_level > 0 && src_max_level < _maxLevel )
{
_maxLevel = src_max_level;
}
OE_NOTICE << LC << "Maximum cache level will be " << _maxLevel << std::endl;
osg::Timer_t startTime = osg::Timer::instance()->tick();
//Estimate the number of tiles
_total = 0;
for (unsigned int level = _minLevel; level <= _maxLevel; level++)
{
double coverageRatio = 0.0;
if (_extents.empty())
{
unsigned int wide, high;
map->getProfile()->getNumTiles( level, wide, high );
_total += (wide * high);
}
else
{
for (std::vector< GeoExtent >::const_iterator itr = _extents.begin(); itr != _extents.end(); itr++)
{
const GeoExtent& extent = *itr;
double boundsArea = extent.area();
TileKey ll = map->getProfile()->createTileKey(extent.xMin(), extent.yMin(), level);
TileKey ur = map->getProfile()->createTileKey(extent.xMax(), extent.yMax(), level);
if (!ll.valid() || !ur.valid()) continue;
int tilesWide = ur.getTileX() - ll.getTileX() + 1;
int tilesHigh = ll.getTileY() - ur.getTileY() + 1;
int tilesAtLevel = tilesWide * tilesHigh;
//OE_NOTICE << "Tiles at level " << level << "=" << tilesAtLevel << std::endl;
/*
bool hasData = false;
for (ImageLayerVector::const_iterator itr = mapf.imageLayers().begin(); itr != mapf.imageLayers().end(); itr++)
{
TileSource* src = itr->get()->getTileSource();
if (src)
{
if (src->hasDataAtLOD( level ))
{
//Compute the percent coverage of this dataset on the current extent
if (src->getDataExtents().size() > 0)
{
double cov = 0.0;
for (unsigned int j = 0; j < src->getDataExtents().size(); j++)
{
GeoExtent b = src->getDataExtents()[j].transform( extent.getSRS());
GeoExtent intersection = b.intersectionSameSRS( extent );
if (intersection.isValid())
{
double coverage = intersection.area() / boundsArea;
cov += coverage; //Assumes the extents aren't overlapping
}
}
if (coverageRatio < cov) coverageRatio = cov;
}
else
{
//We have no way of knowing how much coverage we have
coverageRatio = 1.0;
}
hasData = true;
break;
}
}
}
for (ElevationLayerVector::const_iterator itr = mapf.elevationLayers().begin(); itr != mapf.elevationLayers().end(); itr++)
{
TileSource* src = itr->get()->getTileSource();
if (src)
{
if (src->hasDataAtLOD( level ))
{
//Compute the percent coverage of this dataset on the current extent
if (src->getDataExtents().size() > 0)
{
double cov = 0.0;
for (unsigned int j = 0; j < src->getDataExtents().size(); j++)
{
GeoExtent b = src->getDataExtents()[j].transform( extent.getSRS());
GeoExtent intersection = b.intersectionSameSRS( extent );
if (intersection.isValid())
{
double coverage = intersection.area() / boundsArea;
cov += coverage; //Assumes the extents aren't overlapping
}
}
if (coverageRatio < cov) coverageRatio = cov;
}
else
{
//We have no way of knowing how much coverage we have
coverageRatio = 1.0;
}
hasData = true;
break;
}
}
}
//Adjust the coverage ratio by a fudge factor to try to keep it from being too small,
//tiles are either processed or not and the ratio is exact so will cover tiles partially
//and potentially be too small
double adjust = 4.0;
coverageRatio = osg::clampBetween(coverageRatio * adjust, 0.0, 1.0);
//OE_NOTICE << level << " CoverageRatio = " << coverageRatio << std::endl;
if (hasData)
{
_total += (int)ceil(coverageRatio * (double)tilesAtLevel );
}
*/
_total += tilesAtLevel;
}
}
}
osg::Timer_t endTime = osg::Timer::instance()->tick();
//OE_NOTICE << "Counted tiles in " << osg::Timer::instance()->delta_s(startTime, endTime) << " s" << std::endl;
OE_INFO << "Processing ~" << _total << " tiles" << std::endl;
for (unsigned int i = 0; i < keys.size(); ++i)
{
processKey( mapf, keys[i] );
}
_total = _completed;
if ( _progress.valid()) _progress->reportProgress(_completed, _total, 0, 1, "Finished");
}
osg::Node*
OSGTileFactory::createPlaceholderTile(const MapFrame& mapf,
StreamingTerrain* terrain,
const TileKey& key )
{
// Start out by finding the nearest registered ancestor tile, since the placeholder is
// going to be based on inherited data. Note- the ancestor may not be the immediate
// parent, b/c the parent may or may not be in the scene graph.
TileKey ancestorKey = key.createParentKey();
osg::ref_ptr<StreamingTile> ancestorTile;
while( !ancestorTile.valid() && ancestorKey.valid() )
{
terrain->getTile( ancestorKey.getTileId(), ancestorTile );
if ( !ancestorTile.valid() )
ancestorKey = ancestorKey.createParentKey();
}
if ( !ancestorTile.valid() )
{
OE_WARN << LC << "cannot find ancestor tile for (" << key.str() << ")" <<std::endl;
return 0L;
}
OE_DEBUG << LC << "Creating placeholder for " << key.str() << std::endl;
const MapInfo& mapInfo = mapf.getMapInfo();
bool hasElevation = mapf.elevationLayers().size() > 0;
// Build a "placeholder" tile.
double xmin, ymin, xmax, ymax;
key.getExtent().getBounds( xmin, ymin, xmax, ymax );
// A locator will place the tile on the globe:
osg::ref_ptr<GeoLocator> locator = GeoLocator::createForKey( key, mapInfo );
// The empty tile:
StreamingTile* tile = new StreamingTile( key, locator.get(), terrain->getQuickReleaseGLObjects() );
tile->setTerrainTechnique( terrain->cloneTechnique() );
tile->setVerticalScale( _terrainOptions.verticalScale().value() );
tile->setDataVariance( osg::Object::DYNAMIC );
//tile->setLocator( locator.get() );
// Attach an updatecallback to normalize the edges of TerrainTiles.
#if 0
if ( hasElevation && _terrainOptions.normalizeEdges().get() )
{
tile->setUpdateCallback(new TerrainTileEdgeNormalizerUpdateCallback());
tile->setDataVariance(osg::Object::DYNAMIC);
}
#endif
// Generate placeholder imagery and elevation layers. These "inherit" data from an
// ancestor tile.
{
//Threading::ScopedReadLock parentLock( ancestorTile->getTileLayersMutex() );
addPlaceholderImageLayers ( tile, ancestorTile.get() );
addPlaceholderHeightfieldLayer( tile, ancestorTile.get(), locator.get(), key, ancestorKey );
}
// calculate the switching distances:
osg::BoundingSphere bs = tile->getBound();
double max_range = 1e10;
double radius = bs.radius();
double min_range = radius * _terrainOptions.minTileRangeFactor().get();
// Set the skirt height of the heightfield
osgTerrain::HeightFieldLayer* hfLayer = static_cast<osgTerrain::HeightFieldLayer*>(tile->getElevationLayer());
if (!hfLayer)
{
OE_WARN << LC << "Warning: Couldn't get hfLayer for " << key.str() << std::endl;
}
hfLayer->getHeightField()->setSkirtHeight(radius * _terrainOptions.heightFieldSkirtRatio().get() );
// In a Plate Carre tesselation, scale the heightfield elevations from meters to degrees
if ( mapInfo.isPlateCarre() && hfLayer->getHeightField() )
HeightFieldUtils::scaleHeightFieldToDegrees( hfLayer->getHeightField() );
bool markTileLoaded = false;
if ( _terrainOptions.loadingPolicy()->mode().get() != LoadingPolicy::MODE_STANDARD )
{
markTileLoaded = true;
tile->setHasElevationHint( hasElevation );
}
// install a tile switcher:
tile->attachToTerrain( terrain );
//tile->setTerrain( terrain );
//terrain->registerTile( tile );
osg::Node* result = 0L;
// create a PLOD so we can keep subdividing:
osg::PagedLOD* plod = new osg::PagedLOD();
plod->setCenter( bs.center() );
plod->addChild( tile, min_range, max_range );
if ( key.getLevelOfDetail() < (unsigned int)getTerrainOptions().maxLOD().get() )
{
plod->setFileName( 1, createURI( _engineId, key ) ); //map->getId(), key ) );
plod->setRange( 1, 0.0, min_range );
}
else
{
plod->setRange( 0, 0, FLT_MAX );
}
#if 0 //USE_FILELOCATIONCALLBACK
osgDB::Options* options = new osgDB::Options;
options->setFileLocationCallback( new FileLocationCallback);
plod->setDatabaseOptions( options );
#endif
result = plod;
// Install a callback that will load the actual tile data via the pager.
result->addCullCallback( new PopulateStreamingTileDataCallback( _cull_thread_mapf ) );
// Install a cluster culler (FIXME for cube mode)
//bool isCube = map->getMapOptions().coordSysType() == MapOptions::CSTYPE_GEOCENTRIC_CUBE;
if ( mapInfo.isGeocentric() && !mapInfo.isCube() )
{
osg::ClusterCullingCallback* ccc = createClusterCullingCallback( tile, locator->getEllipsoidModel() );
result->addCullCallback( ccc );
}
return result;
}
bool
ElevationManager::getElevationImpl(double x, double y,
double resolution,
const SpatialReference* srs,
double& out_elevation,
double& out_resolution)
{
if ( _maxDataLevel == 0 || _tileSize == 0 )
{
// this means there are no heightfields.
out_elevation = 0.0;
return true;
}
// this is the ideal LOD for the requested resolution:
unsigned int idealLevel = resolution > 0.0
? _mapf.getProfile()->getLevelOfDetailForHorizResolution( resolution, _tileSize )
: _maxDataLevel;
// based on the heightfields available, this is the best we can theorically do:
unsigned int bestAvailLevel = osg::minimum( idealLevel, _maxDataLevel );
if (_maxLevelOverride >= 0)
{
bestAvailLevel = osg::minimum(bestAvailLevel, (unsigned int)_maxLevelOverride);
}
// transform the input coords to map coords:
double map_x = x, map_y = y;
if ( srs && !srs->isEquivalentTo( _mapf.getProfile()->getSRS() ) )
{
if ( !srs->transform2D( x, y, _mapf.getProfile()->getSRS(), map_x, map_y ) )
{
OE_WARN << LC << "Fail: coord transform failed" << std::endl;
return false;
}
}
osg::ref_ptr<osg::HeightField> hf;
osg::ref_ptr<osgTerrain::TerrainTile> tile;
// get the tilekey corresponding to the tile we need:
TileKey key = _mapf.getProfile()->createTileKey( map_x, map_y, bestAvailLevel );
if ( !key.valid() )
{
OE_WARN << LC << "Fail: coords fall outside map" << std::endl;
return false;
}
// now, see if we already have this tile loaded somewhere:
osgTerrain::TileID tileId = key.getTileId();
if ( !tile.valid() )
{
// next check the local tile cache:
TileTable::const_iterator i = _tileCache.find( tileId );
if ( i != _tileCache.end() )
tile = i->second.get();
}
// if we found it, make sure it has a heightfield in it:
if ( tile.valid() )
{
osgTerrain::HeightFieldLayer* layer = dynamic_cast<osgTerrain::HeightFieldLayer*>(tile->getElevationLayer());
if ( layer )
{
hf = layer->getHeightField();
}
if ( !hf.valid() )
{
tile = NULL;
}
}
// if we didn't find it (or it didn't have heightfield data), build it.
if ( !tile.valid() )
{
//OE_NOTICE << "ElevationManager: cache miss" << std::endl;
// generate the heightfield corresponding to the tile key, automatically falling back
// on lower resolution if necessary:
_mapf.getHeightField( key, true, hf, 0L );
// bail out if we could not make a heightfield a all.
if ( !hf.valid() )
{
OE_WARN << "ElevationManager: unable to create heightfield" << std::endl;
return false;
}
GeoLocator* locator = GeoLocator::createForKey( key, _mapf.getMapInfo() );
tile = new osgTerrain::TerrainTile();
osgTerrain::HeightFieldLayer* layer = new osgTerrain::HeightFieldLayer( hf.get() );
layer->setLocator( locator );
tile->setElevationLayer( layer );
tile->setRequiresNormals( false );
tile->setTerrainTechnique( new osgTerrain::GeometryTechnique );
// store it in the local tile cache.
// TODO: limit the size of the cache with a parallel FIFO list.
_tileCache[tileId] = tile.get();
_tileCacheFIFO.push_back( tileId );
// prune the cache. this is a terrible pruning method.
if ( _tileCache.size() > _maxCacheSize )
{
osgTerrain::TileID id = _tileCacheFIFO.front();
_tileCacheFIFO.pop_front();
if ( tileId != id )
_tileCache.erase( id );
}
}
// see what the actual resolution of the heightfield is.
out_resolution = (double)hf->getXInterval();
// finally it's time to get a height value:
if ( _technique == TECHNIQUE_PARAMETRIC )
{
const GeoExtent& extent = key.getExtent();
double xInterval = extent.width() / (double)(hf->getNumColumns()-1);
double yInterval = extent.height() / (double)(hf->getNumRows()-1);
out_elevation = (double) HeightFieldUtils::getHeightAtLocation( hf.get(), map_x, map_y, extent.xMin(), extent.yMin(), xInterval, yInterval );
return true;
}
else // ( _technique == TECHNIQUE_GEOMETRIC )
{
osg::Vec3d start, end, zero;
if ( _mapf.getMapInfo().isGeocentric() )
{
const osg::EllipsoidModel* ellip = _mapf.getProfile()->getSRS()->getEllipsoid();
ellip->convertLatLongHeightToXYZ(
osg::DegreesToRadians( map_y ),
osg::DegreesToRadians( map_x ),
50000,
start.x(), start.y(), start.z() );
ellip->convertLatLongHeightToXYZ(
osg::DegreesToRadians( map_y ),
osg::DegreesToRadians( map_x ),
-50000,
end.x(), end.y(), end.z() );
ellip->convertLatLongHeightToXYZ(
osg::DegreesToRadians( map_y ),
osg::DegreesToRadians( map_x ),
0.0,
zero.x(), zero.y(), zero.z() );
}
else // PROJECTED
{
start.x() = map_x; start.y() = map_y; start.z() = 50000;
end.x() = map_x; end.y() = map_y; end.z() = -50000;
zero.x() = map_x; zero.y() = map_y; zero.z() = 0;
}
osgUtil::LineSegmentIntersector* i = new osgUtil::LineSegmentIntersector( start, end );
osgUtil::IntersectionVisitor iv;
iv.setIntersector( i );
tile->accept( iv );
osgUtil::LineSegmentIntersector::Intersections& results = i->getIntersections();
if ( !results.empty() )
{
const osgUtil::LineSegmentIntersector::Intersection& result = *results.begin();
osg::Vec3d isectPoint = result.getWorldIntersectPoint();
out_elevation = (isectPoint-end).length2() > (zero-end).length2()
? (isectPoint-zero).length()
: -(isectPoint-zero).length();
return true;
}
OE_WARN << "ElevationManager: no intersections" << std::endl;
return false;
}
}
bool
ElevationQuery::getElevationImpl(const GeoPoint& point,
double& out_elevation,
double desiredResolution,
double* out_actualResolution)
{
osg::Timer_t start = osg::Timer::instance()->tick();
if ( _maxDataLevel == 0 || _tileSize == 0 )
{
// this means there are no heightfields.
out_elevation = 0.0;
return true;
}
//This is the max resolution that we actually have data at this point
unsigned int bestAvailLevel = getMaxLevel( point.x(), point.y(), point.getSRS(), _mapf.getProfile());
if (desiredResolution > 0.0)
{
unsigned int desiredLevel = _mapf.getProfile()->getLevelOfDetailForHorizResolution( desiredResolution, _tileSize );
if (desiredLevel < bestAvailLevel) bestAvailLevel = desiredLevel;
}
OE_DEBUG << "Best available data level " << point.x() << ", " << point.y() << " = " << bestAvailLevel << std::endl;
// transform the input coords to map coords:
GeoPoint mapPoint = point;
if ( point.isValid() && !point.getSRS()->isEquivalentTo( _mapf.getProfile()->getSRS() ) )
{
mapPoint = point.transform(_mapf.getProfile()->getSRS());
if ( !mapPoint.isValid() )
{
OE_WARN << LC << "Fail: coord transform failed" << std::endl;
return false;
}
}
osg::ref_ptr<osg::HeightField> tile;
// get the tilekey corresponding to the tile we need:
TileKey key = _mapf.getProfile()->createTileKey( mapPoint.x(), mapPoint.y(), bestAvailLevel );
if ( !key.valid() )
{
OE_WARN << LC << "Fail: coords fall outside map" << std::endl;
return false;
}
// Check the tile cache. Note that the TileSource already likely has a MemCache
// attached to it. We employ a secondary cache here for a couple reasons. One, this
// cache will store not only the heightfield, but also the tesselated tile in the event
// that we're using GEOMETRIC mode. Second, since the call the getHeightField can
// fallback on a lower resolution, this cache will hold the final resolution heightfield
// instead of trying to fetch the higher resolution one each item.
TileCache::Record record;
if ( _tileCache.get(key, record) )
{
tile = record.value().get();
}
// if we didn't find it, build it.
if ( !tile.valid() )
{
// generate the heightfield corresponding to the tile key, automatically falling back
// on lower resolution if necessary:
_mapf.getHeightField( key, true, tile, 0L );
// bail out if we could not make a heightfield a all.
if ( !tile.valid() )
{
OE_WARN << LC << "Unable to create heightfield for key " << key.str() << std::endl;
return false;
}
_tileCache.insert(key, tile.get());
}
OE_DEBUG << LC << "LRU Cache, hit ratio = " << _tileCache.getStats()._hitRatio << std::endl;
// see what the actual resolution of the heightfield is.
if ( out_actualResolution )
*out_actualResolution = (double)tile->getXInterval();
bool result = true;
const GeoExtent& extent = key.getExtent();
double xInterval = extent.width() / (double)(tile->getNumColumns()-1);
double yInterval = extent.height() / (double)(tile->getNumRows()-1);
out_elevation = (double) HeightFieldUtils::getHeightAtLocation(
tile.get(),
mapPoint.x(), mapPoint.y(),
extent.xMin(), extent.yMin(),
xInterval, yInterval, _mapf.getMapInfo().getElevationInterpolation() );
osg::Timer_t end = osg::Timer::instance()->tick();
_queries++;
_totalTime += osg::Timer::instance()->delta_s( start, end );
return result;
}
osg::HeightField*
ElevationLayer::assembleHeightFieldFromTileSource(const TileKey& key,
ProgressCallback* progress)
{
osg::HeightField* result = 0L;
// Collect the heightfields for each of the intersecting tiles.
GeoHeightFieldVector heightFields;
//Determine the intersecting keys
std::vector< TileKey > intersectingTiles;
getProfile()->getIntersectingTiles( key, intersectingTiles );
// collect heightfield for each intersecting key. Note, we're hitting the
// underlying tile source here, so there's no vetical datum shifts happening yet.
// we will do that later.
if ( intersectingTiles.size() > 0 )
{
for (unsigned int i = 0; i < intersectingTiles.size(); ++i)
{
const TileKey& layerKey = intersectingTiles[i];
if ( isKeyValid(layerKey) )
{
osg::HeightField* hf = createHeightFieldFromTileSource( layerKey, progress );
if ( hf )
{
heightFields.push_back( GeoHeightField(hf, layerKey.getExtent()) );
}
else
{
//We couldn't get a heightfield at the given key so fall back on parent tiles
TileKey parentKey = layerKey.createParentKey();
while (!hf && parentKey.valid())
{
hf = createHeightFieldFromTileSource( parentKey, progress );
if (hf)
{
heightFields.push_back( GeoHeightField(hf, parentKey.getExtent()) );
break;
}
parentKey = parentKey.createParentKey();
}
}
}
}
}
// If we actually got a HeightField, resample/reproject it to match the incoming TileKey's extents.
if (heightFields.size() > 0)
{
unsigned int width = 0;
unsigned int height = 0;
for (GeoHeightFieldVector::iterator itr = heightFields.begin(); itr != heightFields.end(); ++itr)
{
if (itr->getHeightField()->getNumColumns() > width)
width = itr->getHeightField()->getNumColumns();
if (itr->getHeightField()->getNumRows() > height)
height = itr->getHeightField()->getNumRows();
}
result = new osg::HeightField();
result->allocate(width, height);
//Go ahead and set up the heightfield so we don't have to worry about it later
double minx, miny, maxx, maxy;
key.getExtent().getBounds(minx, miny, maxx, maxy);
double dx = (maxx - minx)/(double)(width-1);
double dy = (maxy - miny)/(double)(height-1);
//Create the new heightfield by sampling all of them.
for (unsigned int c = 0; c < width; ++c)
{
double x = minx + (dx * (double)c);
for (unsigned r = 0; r < height; ++r)
{
double y = miny + (dy * (double)r);
//For each sample point, try each heightfield. The first one with a valid elevation wins.
float elevation = NO_DATA_VALUE;
for (GeoHeightFieldVector::iterator itr = heightFields.begin(); itr != heightFields.end(); ++itr)
{
// get the elevation value, at the same time transforming it vertically into the
// requesting key's vertical datum.
float e = 0.0;
if (itr->getElevation(key.getExtent().getSRS(), x, y, INTERP_BILINEAR, key.getExtent().getSRS(), e))
{
elevation = e;
break;
}
}
result->setHeight( c, r, elevation );
}
}
}
return result;
}
bool
ElevationQuery::getElevationImpl(const GeoPoint& point,
double& out_elevation,
double desiredResolution,
double* out_actualResolution)
{
osg::Timer_t start = osg::Timer::instance()->tick();
if ( _mapf.elevationLayers().empty() )
{
// this means there are no heightfields.
out_elevation = 0.0;
return true;
}
// tile size (resolution of elevation tiles)
unsigned tileSize = std::max(_mapf.getMapOptions().elevationTileSize().get(), 2u);
//This is the max resolution that we actually have data at this point
unsigned int bestAvailLevel = getMaxLevel( point.x(), point.y(), point.getSRS(), _mapf.getProfile());
if (desiredResolution > 0.0)
{
unsigned int desiredLevel = _mapf.getProfile()->getLevelOfDetailForHorizResolution( desiredResolution, tileSize );
if (desiredLevel < bestAvailLevel) bestAvailLevel = desiredLevel;
}
OE_DEBUG << LC << "Best available data level " << point.x() << ", " << point.y() << " = " << bestAvailLevel << std::endl;
// transform the input coords to map coords:
GeoPoint mapPoint = point;
if ( point.isValid() && !point.getSRS()->isHorizEquivalentTo( _mapf.getProfile()->getSRS() ) )
{
mapPoint = point.transform(_mapf.getProfile()->getSRS());
if ( !mapPoint.isValid() )
{
OE_WARN << LC << "Fail: coord transform failed" << std::endl;
return false;
}
}
// get the tilekey corresponding to the tile we need:
TileKey key = _mapf.getProfile()->createTileKey( mapPoint.x(), mapPoint.y(), bestAvailLevel );
if ( !key.valid() )
{
OE_WARN << LC << "Fail: coords fall outside map" << std::endl;
return false;
}
bool result = false;
while (!result)
{
GeoHeightField geoHF;
TileCache::Record record;
// Try to get the hf from the cache
if ( _cache.get( key, record ) )
{
geoHF = record.value();
}
else
{
// Create it
osg::ref_ptr<osg::HeightField> hf = new osg::HeightField();
hf->allocate( tileSize, tileSize );
// Initialize the heightfield to nodata
for (unsigned int i = 0; i < hf->getFloatArray()->size(); i++)
{
hf->getFloatArray()->at( i ) = NO_DATA_VALUE;
}
if (_mapf.populateHeightField( hf, key ) )
{
geoHF = GeoHeightField( hf.get(), key.getExtent() );
_cache.insert( key, geoHF );
}
}
if (geoHF.valid())
{
float elevation = 0.0f;
result = geoHF.getElevation( mapPoint.getSRS(), mapPoint.x(), mapPoint.y(), _mapf.getMapInfo().getElevationInterpolation(), mapPoint.getSRS(), elevation);
if (result && elevation != NO_DATA_VALUE)
{
// see what the actual resolution of the heightfield is.
if ( out_actualResolution )
*out_actualResolution = geoHF.getXInterval();
out_elevation = (double)elevation;
break;
}
else
{
result = false;
}
}
if (!result)
{
key = key.createParentKey();
if (!key.valid())
{
break;
}
}
}
osg::Timer_t end = osg::Timer::instance()->tick();
_queries++;
_totalTime += osg::Timer::instance()->delta_s( start, end );
return result;
}
