int list( osg::ArgumentParser& args )
{
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" );
Map* map = mapNode->getMap();
const Cache* cache = map->getCache();
if ( !cache )
return message( "Earth file does not contain a cache." );
std::cout
<< "Cache config: " << std::endl
<< cache->getCacheOptions().getConfig().toJSON(true) << std::endl;
MapFrame mapf( mapNode->getMap() );
TerrainLayerVector layers;
mapf.getLayers(layers);
//std::copy( mapf.imageLayers().begin(), mapf.imageLayers().end(), std::back_inserter(layers) );
//std::copy( mapf.elevationLayers().begin(), mapf.elevationLayers().end(), std::back_inserter(layers) );
for( TerrainLayerVector::iterator i =layers.begin(); i != layers.end(); ++i )
{
TerrainLayer* layer = i->get();
bool useMFP =
layer->getProfile() &&
layer->getProfile()->getSRS()->isSphericalMercator() &&
mapNode->getMapNodeOptions().getTerrainOptions().enableMercatorFastPath() == true;
const Profile* cacheProfile = useMFP ? layer->getProfile() : map->getProfile();
TerrainLayer::CacheBinMetadata* meta = layer->getCacheBinMetadata(cacheProfile);
if (meta)
{
Config conf = meta->getConfig();
std::cout << "Layer \"" << layer->getName() << "\", cache metadata =" << std::endl
<< conf.toJSON(true) << std::endl;
}
else
{
std::cout << "Layer \"" << layer->getName() << "\": no cache information"
<< std::endl;
}
}
return 0;
}
int
main(int argc, char** argv)
{
osg::ArgumentParser arguments(&argc,argv);
osgViewer::Viewer viewer(arguments);
viewer.setCameraManipulator( new EarthManipulator(arguments) );
osg::Node* node = MapNodeHelper().load(arguments, &viewer);
if ( node )
{
MapNode* mapNode = MapNode::get(node);
if (!mapNode)
return -1;
MyCallback* myCallback = new MyCallback();
// Install a callback on each loaded layer.
LayerVector layers;
mapNode->getMap()->getLayers(layers);
for (LayerVector::iterator layer = layers.begin(); layer != layers.end(); ++layer)
{
layer->get()->getSceneGraphCallbacks()->add( myCallback );
}
viewer.setSceneData( node );
return viewer.run();
}
else
{
return usage(argv[0]);
}
return 0;
}
int
seed( osg::ArgumentParser& args )
{
//Read the min level
unsigned int minLevel = 0;
while (args.read("--min-level", minLevel));
//Read the max level
unsigned int maxLevel = 5;
while (args.read("--max-level", maxLevel));
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 );
}
//Read the cache override directory
std::string cachePath;
while (args.read("--cache-path", cachePath));
//Read the cache type
std::string cacheType;
while (args.read("--cache-type", cacheType));
bool verbose = args.read("--verbose");
//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" );
CacheSeed seeder;
seeder.setMinLevel( minLevel );
seeder.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;
seeder.addExtent( extent );
}
if (verbose)
{
seeder.setProgressCallback(new ConsoleProgressCallback);
}
seeder.seed( mapNode->getMap() );
return 0;
}
int main(int argc, char** argv)
{
osg::ArgumentParser arguments(&argc,argv);
if ( arguments.read( "--help" ) || argc < 2 )
{
OE_NOTICE << LC << std::endl << std::endl
<< "osgearth_labels <earthfile>" << std::endl
<< " --features <filename> : name of shapefile containing feature labels" << std::endl
<< " --label-attr <attribute> : attribute containing label text" << std::endl
<< " --priority-attr <attribute> : attribute containing priority value" << std::endl
<< " --show-duplicates : draws duplicate labels (usually won't)" << std::endl;
return 0;
}
if ( !arguments.read( "--features", g_featureFile ) )
g_featureFile = "../data/world.shp";
if ( !arguments.read( "--label-attr", g_labelAttr ) )
g_labelAttr = "cntry_name";
if ( !arguments.read( "--priority-attr", g_priorityAttr ) )
g_priorityAttr = "cntry_pop";
if ( arguments.read( "--show-duplicates" ) )
g_removeDupes = false;
osgViewer::Viewer viewer(arguments);
osg::Group* root = new osg::Group();
osg::Node* node = osgDB::readNodeFiles( arguments );
if ( node )
root->addChild( node );
MapNode* mapNode = MapNode::findMapNode(node);
if ( mapNode )
{
viewer.setSceneData( root );
viewer.setCameraManipulator( new osgEarth::Util::EarthManipulator );
//root->addChild( new ControlCanvas( &viewer ) );
// load up some labels.
root->addChild( createLabels(mapNode->getMap()) );
}
// add some stock OSG handlers:
viewer.addEventHandler(new osgViewer::StatsHandler());
viewer.addEventHandler(new osgViewer::WindowSizeHandler());
viewer.addEventHandler(new osgViewer::ThreadingHandler());
viewer.addEventHandler(new osgViewer::LODScaleHandler());
viewer.addEventHandler(new osgGA::StateSetManipulator(viewer.getCamera()->getOrCreateStateSet()));
viewer.addEventHandler(new osgViewer::HelpHandler(arguments.getApplicationUsage()));
return viewer.run();
}
int main(int argc, char** argv)
{
osg::ArgumentParser arguments(&argc, argv);
// create a viewer:
osgViewer::Viewer viewer(arguments);
// Tell osgEarth to use the "quadtree" terrain driver by default.
// Elevation data attribution is only available in this driver!
osgEarth::Registry::instance()->setDefaultTerrainEngineDriverName( "quadtree" );
// install our default manipulator (do this before calling load)
viewer.setCameraManipulator( new EarthManipulator() );
// load an earth file, and support all or our example command-line options
// and earth file <external> tags
osg::Node* node = MapNodeHelper().load( arguments, &viewer );
if ( node )
{
MapNode* mapNode = MapNode::findMapNode(node);
if ( !mapNode )
return -1;
if ( mapNode->getMap()->getNumElevationLayers() == 0 )
OE_WARN << "No elevation layers! The contour will be very boring." << std::endl;
// Set up a transfer function for the elevation contours.
osg::ref_ptr<osg::TransferFunction1D> xfer = new osg::TransferFunction1D();
xfer->setColor( -3000.0f, osg::Vec4f(0,0,0.5,1), false );
xfer->setColor( -10.0f, osg::Vec4f(0,0,0,1), false );
xfer->setColor( 10.0f, osg::Vec4f(0,1,0,1), false );
xfer->setColor( 1500.0f, osg::Vec4f(1,0,0,1), false );
xfer->setColor( 3000.0f, osg::Vec4f(1,1,1,1), false );
xfer->updateImage();
// request an available texture unit:
int unit;
mapNode->getTerrainEngine()->getTextureCompositor()->reserveTextureImageUnit(unit);
// install the contour shaders:
osg::Group* root = new osg::Group();
root->setStateSet( createStateSet(xfer.get(), unit) );
root->addChild( node );
viewer.setSceneData( root );
viewer.run();
}
else
{
OE_NOTICE
<< "\nUsage: " << argv[0] << " file.earth" << std::endl
<< MapNodeHelper().usage() << std::endl;
}
return 0;
}
// main program.
int main(int argc, char** argv)
{
// set up the viewer
osg::ArgumentParser arguments(&argc,argv);
osgViewer::Viewer viewer(arguments);
// make sure we have a shape file.
std::string shapefile;
if ( !arguments.read("--shapefile", shapefile) )
return usage("Missing required --shapefile argument");
// install a motion model
viewer.setCameraManipulator( new osgEarth::Util::EarthManipulator() );
// create a visible imagery layer:
ImageLayer* imagery = createImageryLayer();
// create a masking layer using the shapefile:
ImageLayer* sharedLayer = createSharedLayer( shapefile );
// create a new map and add our two layers.
MapNode* mapnode = new MapNode();
mapnode->getMap()->addImageLayer( imagery );
mapnode->getMap()->addImageLayer( sharedLayer );
// make a custom color-filter shader that will modulate the imagery
// using the texture from the shared layer. (Using a ColorFilter
// will apply the effect to just one layer; if you want to apply it
// to all layers, you can just create a VirtualProgram and apply that
// the the mapnode->getTerrainEngine() state set.)
ColorFilter* filter = new MyColorFilter( sharedLayer );
imagery->addColorFilter( filter );
// done!
viewer.setSceneData( mapnode );
MapNodeHelper().configureView(&viewer);
return viewer.run();
}
int main(int argc, char** argv)
{
osg::ArgumentParser arguments(&argc, argv);
// create a viewer:
osgViewer::Viewer viewer(arguments);
// Tell osgEarth to use the "quadtree" terrain driver by default.
// Elevation data attribution is only available in this driver!
osgEarth::Registry::instance()->setDefaultTerrainEngineDriverName( "quadtree" );
// install our default manipulator (do this before calling load)
viewer.setCameraManipulator( new EarthManipulator() );
osg::Uniform* verticalScale = new osg::Uniform(osg::Uniform::FLOAT, "verticalScale");
verticalScale->set( 1.0f );
osgEarth::Util::Controls::Control* ui = createUI( verticalScale );
// load an earth file, and support all or our example command-line options
// and earth file <external> tags
osg::Node* node = MapNodeHelper().load( arguments, &viewer, ui );
if ( node )
{
MapNode* mapNode = MapNode::findMapNode(node);
if ( !mapNode )
return -1;
if ( mapNode->getMap()->getNumElevationLayers() == 0 )
OE_WARN << "No elevation layers! Scaling will be very boring." << std::endl;
// install the shader program and install our controller uniform:
osg::Group* root = new osg::Group();
root->setStateSet( createStateSet() );
root->getStateSet()->addUniform( verticalScale );
root->addChild( node );
viewer.setSceneData( root );
viewer.run();
}
else
{
OE_NOTICE
<< "\nUsage: " << argv[0] << " file.earth" << std::endl
<< MapNodeHelper().usage() << std::endl;
}
return 0;
}
int
main(int argc, char** argv)
{
osg::ArgumentParser arguments(&argc,argv);
// help?
if ( arguments.read("--help") )
return usage(argv[0]);
// create a viewer:
osgViewer::Viewer viewer(arguments);
// Tell the database pager to not modify the unref settings
viewer.getDatabasePager()->setUnrefImageDataAfterApplyPolicy( false, false );
// install our default manipulator (do this before calling load)
viewer.setCameraManipulator( new osgEarth::Util::EarthManipulator() );
// load an earth file, and support all or our example command-line options
// and earth file <external> tags
osg::Group* node = MapNodeHelper().load(arguments, &viewer, createUI());
if ( node )
{
// Make sure we don't already have a sky.
SkyNode* skyNode = osgEarth::findTopMostNodeOfType<SkyNode>(node);
if (skyNode)
{
OE_WARN << LC << "Earth file already has a Sky. This example requires an "
"earth file that does not use a sky already.\n";
return -1;
}
viewer.getCamera()->setNearFarRatio(0.00002);
viewer.getCamera()->setSmallFeatureCullingPixelSize(-1.0f);
MapNode* mapNode = MapNode::findMapNode( node );
// Create SilverLiningNode from SilverLiningOptions
osgEarth::SilverLining::SilverLiningOptions slOptions;
slOptions.user() = "my_user_name";
slOptions.licenseCode() = "my_license_code";
slOptions.cloudsMaxAltitude() = 100000;
const char* ev_sl = ::getenv("SILVERLINING_PATH");
if ( ev_sl )
{
slOptions.resourcePath() = osgDB::concatPaths(
std::string(ev_sl),
"Resources" );
}
else
{
OE_WARN << LC
<< "No resource path! SilverLining might not initialize properly. "
<< "Consider setting the SILVERLINING_PATH environment variable."
<< std::endl;
}
// TODO: uncommenting the callback on the following line results in a crash when SeedClouds is called.
s_settings.sky = new SilverLiningNode(
mapNode->getMap(),
slOptions,
new SLCallback() );
// insert the new sky above the map node.
osgEarth::insertParent(s_settings.sky, mapNode);
// use the topmost node.
viewer.setSceneData(osgEarth::findTopOfGraph(node));
// connects the sky's light to the viewer.
s_settings.sky->attach(&viewer);
return viewer.run();
}
else
{
return usage(argv[0]);
}
}
int
main(int argc, char** argv)
{
osg::ArgumentParser arguments(&argc,argv);
if ( arguments.read("--help") )
return usage(argv[0]);
// general setup:
osgViewer::Viewer viewer(arguments);
viewer.getDatabasePager()->setUnrefImageDataAfterApplyPolicy( false, false );
viewer.setCameraManipulator( new EarthManipulator(arguments) );
viewer.getCamera()->setSmallFeatureCullingPixelSize(-1.0f);
viewer.getCamera()->setNearFarRatio(0.00002);
// load an earth file, and support all or our example command-line options
// and earth file <external> tags
osg::Node* node = MapNodeHelper().load( arguments, &viewer );
if ( node )
{
MapNode* mapNode = MapNode::get(node);
if ( !mapNode )
return usage(argv[0]);
// Create the WFS driver:
osgEarth::Drivers::WFSFeatureOptions wfs;
wfs.url() = osgEarth::URI("http://demo.opengeo.org/geoserver/wfs");
wfs.typeName() = "states";
wfs.outputFormat() = "json"; // JSON or GML
// Configure a rendering style:
Style style;
style.setName( "states" );
LineSymbol* line = style.getOrCreate<LineSymbol>();
line->stroke()->color() = Color::Yellow;
line->stroke()->width() = 5.0f;
line->stroke()->widthUnits() = Units::PIXELS;
AltitudeSymbol* alt = style.getOrCreate<AltitudeSymbol>();
alt->clamping() = AltitudeSymbol::CLAMP_TO_TERRAIN;
alt->technique() = AltitudeSymbol::TECHNIQUE_DRAPE;
// Configure a model layer to render the features:
osgEarth::Drivers::FeatureGeomModelOptions geom;
geom.featureOptions() = wfs;
geom.styles() = new StyleSheet();
geom.styles()->addStyle(style);
// Make the new layer and add it to the map.
ModelLayerOptions layerOptions("states", geom);
ModelLayer* layer = new ModelLayer(layerOptions);
mapNode->getMap()->addModelLayer(layer);
viewer.setSceneData( node );
return viewer.run();
}
else
{
return usage(argv[0]);
}
}
int
main(int argc, char** argv)
{
osg::ArgumentParser arguments(&argc,argv);
osgViewer::Viewer viewer(arguments);
// parse command line:
bool isUTM = arguments.read("--utm");
bool isMGRS = arguments.read("--mgrs");
bool isGeodetic = arguments.read("--geodetic");
bool isGARS = arguments.read("--gars");
// load the .earth file from the command line.
MapNode* mapNode = MapNode::load( arguments );
if ( !mapNode )
return usage( "Failed to load a map from the .earth file" );
// install our manipulator:
viewer.setCameraManipulator( new EarthManipulator() );
// root scene graph:
osg::Group* root = new osg::Group();
root->addChild( mapNode );
Formatter* formatter = 0L;
if ( isUTM )
{
UTMGraticule* gr = new UTMGraticule();
mapNode->getMap()->addLayer(gr);
formatter = new MGRSFormatter();
}
else if ( isMGRS )
{
MGRSGraticule* gr = new MGRSGraticule();
mapNode->getMap()->addLayer(gr);
formatter = new MGRSFormatter();
}
else if ( isGARS )
{
GARSGraticule* gr = new GARSGraticule();
mapNode->getMap()->addLayer(gr);
formatter = new LatLongFormatter();
}
else // if ( isGeodetic )
{
GeodeticGraticule* gr = new GeodeticGraticule();
mapNode->getMap()->addLayer(gr);
formatter = new LatLongFormatter();
}
// mouse coordinate readout:
ControlCanvas* canvas = new ControlCanvas();
root->addChild( canvas );
VBox* vbox = new VBox();
canvas->addControl( vbox );
LabelControl* readout = new LabelControl();
vbox->addControl( readout );
MouseCoordsTool* tool = new MouseCoordsTool( mapNode );
tool->addCallback( new MouseCoordsLabelCallback(readout, formatter) );
viewer.addEventHandler( tool );
// finalize setup and run.
viewer.setSceneData( root );
viewer.addEventHandler(new osgViewer::StatsHandler());
viewer.addEventHandler(new osgViewer::WindowSizeHandler());
viewer.addEventHandler(new osgViewer::ThreadingHandler());
viewer.addEventHandler(new osgGA::StateSetManipulator(viewer.getCamera()->getOrCreateStateSet()));
return viewer.run();
}
virtual ReadResult readNode(std::istream& in, const osgDB::Options* readOptions) const
{
// pull the URI context from the options structure (since we're reading
// from an "anonymous" stream here)
URIContext uriContext( readOptions );
osg::ref_ptr<XmlDocument> doc = XmlDocument::load( in, uriContext );
if ( !doc.valid() )
return ReadResult::ERROR_IN_READING_FILE;
Config docConf = doc->getConfig();
// support both "map" and "earth" tag names at the top level
Config conf;
if ( docConf.hasChild( "map" ) )
conf = docConf.child( "map" );
else if ( docConf.hasChild( "earth" ) )
conf = docConf.child( "earth" );
osg::ref_ptr<osg::Node> node;
if ( !conf.empty() )
{
// see if we were given a reference URI to use:
std::string refURI = uriContext.referrer();
if ( conf.value("version") == "1" )
{
OE_INFO << LC << "Detected a version 1.x earth file" << std::endl;
EarthFileSerializer1 ser;
node = ser.deserialize( conf, refURI );
}
else
{
if ( conf.value("version") != "2" )
OE_DEBUG << LC << "No valid earth file version; assuming version='2'" << std::endl;
// attempt to parse a "default options" JSON string:
std::string defaultConfStr;
if ( readOptions )
{
defaultConfStr = readOptions->getPluginStringData("osgEarth.defaultOptions");
if ( !defaultConfStr.empty() )
{
Config optionsConf("options");
if (optionsConf.fromJSON(defaultConfStr))
{
//OE_NOTICE << "\n\nOriginal = \n" << conf.toJSON(true) << "\n";
Config* original = conf.mutable_child("options");
if ( original )
{
recursiveUniqueKeyMerge(optionsConf, *original);
}
if ( !optionsConf.empty() )
{
conf.set("options", optionsConf);
}
//OE_NOTICE << "\n\nMerged = \n" << conf.toJSON(true) << "\n";
}
}
}
EarthFileSerializer2 ser;
node = ser.deserialize( conf, refURI );
}
}
MapNode* mapNode = MapNode::get(node.get());
if (mapNode)
{
// If the user passed in a cache object, apply it to the map now
CacheSettings* cacheSettings = CacheSettings::get(readOptions);
if (cacheSettings && cacheSettings->getCache())
{
mapNode->getMap()->setCache( cacheSettings->getCache() );
OE_INFO << LC << "Applied user-supplied cache to the Map\n";
}
}
return ReadResult(node.get());
}
int
purge( osg::ArgumentParser& args )
{
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" );
Map* map = mapNode->getMap();
if ( !map->getCache() )
return message( "Earth file does not contain a cache." );
std::vector<Entry> entries;
ImageLayerVector imageLayers;
map->getLayers( imageLayers );
for( ImageLayerVector::const_iterator i = imageLayers.begin(); i != imageLayers.end(); ++i )
{
ImageLayer* layer = i->get();
bool useMFP =
layer->getProfile() &&
layer->getProfile()->getSRS()->isSphericalMercator() &&
mapNode->getMapNodeOptions().getTerrainOptions().enableMercatorFastPath() == true;
const Profile* cacheProfile = useMFP ? layer->getProfile() : map->getProfile();
CacheSettings* cacheSettings = layer->getCacheSettings();
if (cacheSettings)
{
CacheBin* bin = cacheSettings->getCacheBin();
if ( bin )
{
entries.push_back(Entry());
entries.back()._isImage = true;
entries.back()._name = i->get()->getName();
entries.back()._bin = bin;
}
}
}
ElevationLayerVector elevationLayers;
map->getLayers( elevationLayers );
for( ElevationLayerVector::const_iterator i = elevationLayers.begin(); i != elevationLayers.end(); ++i )
{
ElevationLayer* layer = i->get();
bool useMFP =
layer->getProfile() &&
layer->getProfile()->getSRS()->isSphericalMercator() &&
mapNode->getMapNodeOptions().getTerrainOptions().enableMercatorFastPath() == true;
const Profile* cacheProfile = useMFP ? layer->getProfile() : map->getProfile();
CacheSettings* cacheSettings = layer->getCacheSettings();
if (cacheSettings)
{
CacheBin* bin = cacheSettings->getCacheBin();
if (bin)
{
entries.push_back(Entry());
entries.back()._isImage = false;
entries.back()._name = i->get()->getName();
entries.back()._bin = bin;
}
}
}
if ( entries.size() > 0 )
{
std::cout << std::endl;
for( unsigned i=0; i<entries.size(); ++i )
{
std::cout << (i+1) << ") " << entries[i]._name << " (" << (entries[i]._isImage? "image" : "elevation" ) << ")" << std::endl;
}
std::cout
<< std::endl
<< "Enter number of cache to purge, or <enter> to quit: "
<< std::flush;
std::string input;
std::getline( std::cin, input );
if ( !input.empty() )
{
unsigned k = as<unsigned>(input, 0L);
if ( k > 0 && k <= entries.size() )
{
Config meta = entries[k-1]._bin->readMetadata();
if ( !meta.empty() )
{
std::cout
<< std::endl
<< "Cache METADATA:" << std::endl
<< meta.toJSON()
<< std::endl << std::endl;
}
std::cout
<< "Are you sure (y/N)? "
<< std::flush;
std::getline( std::cin, input );
if ( input == "y" || input == "Y" )
{
std::cout << "Purging.." << std::flush;
entries[k-1]._bin->clear();
}
else
{
std::cout << "No action taken." << std::endl;
}
}
else
{
std::cout << "Invalid choice." << std::endl;
}
}
else
{
std::cout << "No action taken." << std::endl;
}
}
return 0;
}
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;
}
int
seed( osg::ArgumentParser& args )
{
//Read the min level
unsigned int minLevel = 0;
while (args.read("--min-level", minLevel));
//Read the max level
unsigned int maxLevel = 5;
while (args.read("--max-level", maxLevel));
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 );
}
//Read the cache override directory
std::string cachePath;
while (args.read("--cache-path", cachePath));
//Read the cache type
std::string cacheType;
while (args.read("--cache-type", cacheType));
bool verbose = args.read("--verbose");
//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" );
CacheSeed seeder;
seeder.setMinLevel( minLevel );
seeder.setMaxLevel( maxLevel );
// 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 );
features->initialize();
features->getFeatureProfile();
osg::ref_ptr< FeatureCursor > cursor = features->createFeatureCursor();
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() );
}
}
for (unsigned int i = 0; i < bounds.size(); i++)
{
GeoExtent extent(mapNode->getMapSRS(), bounds[i]);
OE_DEBUG << "Adding extent " << extent.toString() << std::endl;
seeder.addExtent( extent );
}
if (verbose)
{
seeder.setProgressCallback(new ConsoleProgressCallback);
}
osg::Timer_t start = osg::Timer::instance()->tick();
seeder.seed( mapNode->getMap() );
osg::Timer_t end = osg::Timer::instance()->tick();
OE_NOTICE << "Completed seeding in " << prettyPrintTime( osg::Timer::instance()->delta_s( start, end ) ) << std::endl;
return 0;
}
