void TileVisitor::estimate()
{
//Estimate the number of tiles
CacheEstimator est;
est.setMinLevel( _minLevel );
est.setMaxLevel( _maxLevel );
est.setProfile( _profile );
for (unsigned int i = 0; i < _extents.size(); i++)
{
est.addExtent( _extents[ i ] );
}
_total = est.getNumTiles();
}
void CacheSeed::seed( Map* map )
{
// We must do this to avoid an error message in OpenSceneGraph b/c the findWrapper method doesn't appear to be threadsafe.
// This really isn't a big deal b/c this only effects data that is already cached.
osgDB::ObjectWrapper* wrapper = osgDB::Registry::instance()->getObjectWrapperManager()->findWrapper( "osg::Image" );
osg::Timer_t startTime = osg::Timer::instance()->tick();
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;
//Estimate the number of tiles
_total = 0;
CacheEstimator est;
est.setMinLevel( _minLevel );
est.setMaxLevel( _maxLevel );
est.setProfile( map->getProfile() );
for (unsigned int i = 0; i < _extents.size(); i++)
{
est.addExtent( _extents[ i ] );
}
_total = est.getNumTiles();
OE_INFO << "Processing ~" << _total << " tiles" << std::endl;
// Initialize the operations queue
_queue = new osg::OperationQueue;
osg::Timer_t endTime = osg::Timer::instance()->tick();
// Start the threads
std::vector< osg::ref_ptr< osg::OperationsThread > > threads;
for (unsigned int i = 0; i < _numThreads; i++)
{
osg::OperationsThread* thread = new osg::OperationsThread();
thread->setOperationQueue(_queue.get());
thread->start();
threads.push_back( thread );
}
OE_NOTICE << "Startup time " << osg::Timer::instance()->delta_s( startTime, endTime ) << std::endl;
// Add the root keys to the queue
for (unsigned int i = 0; i < keys.size(); ++i)
{
//processKey( mapf, keys[i] );
_queue.get()->add( new CacheTileOperation( mapf, *this, keys[i]) );
}
bool done = false;
while (!done)
{
OpenThreads::Thread::microSleep(500000); // sleep for half a second
done = true;
if (_queue->getNumOperationsInQueue() > 0)
{
done = false;
continue;
}
else
{
// Make sure no threads are currently working on an operation, which actually might add MORE operations since we are doing a quadtree traversal
for (unsigned int i = 0; i < threads.size(); i++)
{
if (threads[i]->getCurrentOperation())
{
done = false;
continue;
}
}
}
}
_total = _completed;
if ( _progress.valid()) _progress->reportProgress(_completed, _total, 0, 1, "Finished");
}
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;
//Estimate the number of tiles
_total = 0;
CacheEstimator est;
est.setMinLevel( _minLevel );
est.setMaxLevel( _maxLevel );
est.setProfile( map->getProfile() );
for (unsigned int i = 0; i < _extents.size(); i++)
{
est.addExtent( _extents[ i ] );
}
_total = est.getNumTiles();
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");
}
int
seed( osg::ArgumentParser& args )
{
osgDB::Registry::instance()->getReaderWriterForExtension("png");
osgDB::Registry::instance()->getReaderWriterForExtension("jpg");
osgDB::Registry::instance()->getReaderWriterForExtension("tiff");
//Read the min level
int minLevel = -1;
while (args.read("--min-level", minLevel));
//Read the max level
int maxLevel = -1;
while (args.read("--max-level", maxLevel));
bool estimate = args.read("--estimate");
std::vector< Bounds > bounds;
// restrict packaging to user-specified bounds.
double xmin=DBL_MAX, ymin=DBL_MAX, xmax=DBL_MIN, ymax=DBL_MIN;
while (args.read("--bounds", xmin, ymin, xmax, ymax ))
{
Bounds b;
b.xMin() = xmin, b.yMin() = ymin, b.xMax() = xmax, b.yMax() = ymax;
bounds.push_back( b );
}
std::string tileList;
while (args.read( "--tiles", tileList ) );
bool verbose = args.read("--verbose");
unsigned int batchSize = 0;
args.read("--batchsize", batchSize);
// Read the concurrency level
unsigned int concurrency = 0;
args.read("-c", concurrency);
args.read("--concurrency", concurrency);
int imageLayerIndex = -1;
args.read("--image", imageLayerIndex);
int elevationLayerIndex = -1;
args.read("--elevation", elevationLayerIndex);
//Read in the earth file.
osg::ref_ptr<osg::Node> node = osgDB::readNodeFiles( args );
if ( !node.valid() )
return usage( "Failed to read .earth file." );
MapNode* mapNode = MapNode::findMapNode( node.get() );
if ( !mapNode )
return usage( "Input file was not a .earth file" );
// Read in an index shapefile
std::string index;
while (args.read("--index", index))
{
//Open the feature source
OGRFeatureOptions featureOpt;
featureOpt.url() = index;
osg::ref_ptr< FeatureSource > features = FeatureSourceFactory::create( featureOpt );
Status status = features->open();
if (status.isOK())
{
osg::ref_ptr< FeatureCursor > cursor = features->createFeatureCursor(0L);
while (cursor.valid() && cursor->hasMore())
{
osg::ref_ptr< Feature > feature = cursor->nextFeature();
osgEarth::Bounds featureBounds = feature->getGeometry()->getBounds();
GeoExtent ext( feature->getSRS(), featureBounds );
ext = ext.transform( mapNode->getMapSRS() );
bounds.push_back( ext.bounds() );
}
}
else
{
OE_WARN << status.message() << "\n";
}
}
// If they requested to do an estimate then don't do the seed, just print out the estimated values.
if (estimate)
{
CacheEstimator est;
if ( minLevel >= 0 )
est.setMinLevel( minLevel );
if ( maxLevel >= 0 )
est.setMaxLevel( maxLevel );
est.setProfile( mapNode->getMap()->getProfile() );
for (unsigned int i = 0; i < bounds.size(); i++)
{
GeoExtent extent(mapNode->getMapSRS(), bounds[i]);
OE_DEBUG << "Adding extent " << extent.toString() << std::endl;
est.addExtent( extent );
}
unsigned int numTiles = est.getNumTiles();
double size = est.getSizeInMB();
double time = est.getTotalTimeInSeconds();
std::cout << "Cache Estimation " << std::endl
<< "---------------- " << std::endl
<< "Total number of tiles: " << numTiles << std::endl
<< "Size on disk: " << osgEarth::prettyPrintSize( size ) << std::endl
<< "Total time: " << osgEarth::prettyPrintTime( time ) << std::endl;
return 0;
}
osg::ref_ptr< TileVisitor > visitor;
// If we are given a task file, load it up and create a new TileKeyListVisitor
if (!tileList.empty())
{
TaskList tasks( mapNode->getMap()->getProfile() );
tasks.load( tileList );
TileKeyListVisitor* v = new TileKeyListVisitor();
v->setKeys( tasks.getKeys() );
visitor = v;
OE_DEBUG << "Read task list with " << tasks.getKeys().size() << " tasks" << std::endl;
}
// If we dont' have a visitor create one.
if (!visitor.valid())
{
if (args.read("--mt"))
{
// Create a multithreaded visitor
MultithreadedTileVisitor* v = new MultithreadedTileVisitor();
if (concurrency > 0)
{
v->setNumThreads(concurrency);
}
visitor = v;
}
else if (args.read("--mp"))
{
// Create a multiprocess visitor
MultiprocessTileVisitor* v = new MultiprocessTileVisitor();
if (concurrency > 0)
{
v->setNumProcesses(concurrency);
}
if (batchSize > 0)
{
v->setBatchSize(batchSize);
}
// Try to find the earth file
std::string earthFile;
for(int pos=1;pos<args.argc();++pos)
{
if (!args.isOption(pos))
{
earthFile = args[ pos ];
break;
}
}
v->setEarthFile( earthFile );
visitor = v;
}
else
{
// Create a single thread visitor
visitor = new TileVisitor();
}
}
osg::ref_ptr< ProgressCallback > progress = new ConsoleProgressCallback();
if (verbose)
{
visitor->setProgressCallback( progress.get() );
}
if ( minLevel >= 0 )
visitor->setMinLevel( minLevel );
if ( maxLevel >= 0 )
visitor->setMaxLevel( maxLevel );
for (unsigned int i = 0; i < bounds.size(); i++)
{
GeoExtent extent(mapNode->getMapSRS(), bounds[i]);
OE_DEBUG << "Adding extent " << extent.toString() << std::endl;
visitor->addExtent( extent );
}
// Initialize the seeder
CacheSeed seeder;
seeder.setVisitor(visitor.get());
osgEarth::Map* map = mapNode->getMap();
// They want to seed an image layer
if (imageLayerIndex >= 0)
{
osg::ref_ptr< ImageLayer > layer = map->getLayerAt<ImageLayer>( imageLayerIndex );
if (layer)
{
OE_NOTICE << "Seeding single layer " << layer->getName() << std::endl;
osg::Timer_t start = osg::Timer::instance()->tick();
seeder.run(layer.get(), map);
osg::Timer_t end = osg::Timer::instance()->tick();
if (verbose)
{
OE_NOTICE << "Completed seeding layer " << layer->getName() << " in " << prettyPrintTime( osg::Timer::instance()->delta_s( start, end ) ) << std::endl;
}
}
else
{
std::cout << "Failed to find an image layer at index " << imageLayerIndex << std::endl;
return 1;
}
}
// They want to seed an elevation layer
else if (elevationLayerIndex >= 0)
{
osg::ref_ptr< ElevationLayer > layer = map->getLayerAt<ElevationLayer>( elevationLayerIndex );
if (layer)
{
OE_NOTICE << "Seeding single layer " << layer->getName() << std::endl;
osg::Timer_t start = osg::Timer::instance()->tick();
seeder.run(layer.get(), map);
osg::Timer_t end = osg::Timer::instance()->tick();
if (verbose)
{
OE_NOTICE << "Completed seeding layer " << layer->getName() << " in " << prettyPrintTime( osg::Timer::instance()->delta_s( start, end ) ) << std::endl;
}
}
else
{
std::cout << "Failed to find an elevation layer at index " << elevationLayerIndex << std::endl;
return 1;
}
}
// They want to seed the entire map
else
{
TerrainLayerVector terrainLayers;
map->getLayers(terrainLayers);
// Seed all the map layers
for (unsigned int i = 0; i < terrainLayers.size(); ++i)
{
osg::ref_ptr< TerrainLayer > layer = terrainLayers[i].get();
OE_NOTICE << "Seeding layer" << layer->getName() << std::endl;
osg::Timer_t start = osg::Timer::instance()->tick();
seeder.run(layer.get(), map);
osg::Timer_t end = osg::Timer::instance()->tick();
if (verbose)
{
OE_NOTICE << "Completed seeding layer " << layer->getName() << " in " << prettyPrintTime( osg::Timer::instance()->delta_s( start, end ) ) << std::endl;
}
}
//for (unsigned int i = 0; i < map->getNumElevationLayers(); ++i)
//{
// osg::ref_ptr< ElevationLayer > layer = map->getElevationLayerAt(i);
// OE_NOTICE << "Seeding layer" << layer->getName() << std::endl;
// osg::Timer_t start = osg::Timer::instance()->tick();
// seeder.run(layer.get(), map);
// osg::Timer_t end = osg::Timer::instance()->tick();
// if (verbose)
// {
// OE_NOTICE << "Completed seeding layer " << layer->getName() << " in " << prettyPrintTime( osg::Timer::instance()->delta_s( start, end ) ) << std::endl;
// }
//}
}
return 0;
}
