osg::Node* SingleKeyNodeFactory::createTile(TileModel* model, bool setupChildrenIfNecessary) { // compile the model into a node: TileNode* tileNode = _modelCompiler->compile( model, _frame ); // see if this tile might have children. bool prepareForChildren = setupChildrenIfNecessary && model->_tileKey.getLOD() < *_options.maxLOD(); osg::Node* result = 0L; if ( prepareForChildren ) { //Compute the min range based on the 2D size of the tile osg::BoundingSphere bs = tileNode->getBound(); GeoExtent extent = model->_tileKey.getExtent(); GeoPoint lowerLeft(extent.getSRS(), extent.xMin(), extent.yMin(), 0.0, ALTMODE_ABSOLUTE); GeoPoint upperRight(extent.getSRS(), extent.xMax(), extent.yMax(), 0.0, ALTMODE_ABSOLUTE); osg::Vec3d ll, ur; lowerLeft.toWorld( ll ); upperRight.toWorld( ur ); double radius = (ur - ll).length() / 2.0; float minRange = (float)(radius * _options.minTileRangeFactor().value()); TilePagedLOD* plod = new TilePagedLOD( _engineUID, _liveTiles, _deadTiles ); plod->setCenter ( bs.center() ); plod->addChild ( tileNode ); plod->setRange ( 0, minRange, FLT_MAX ); plod->setFileName( 1, Stringify() << tileNode->getKey().str() << "." << _engineUID << ".osgearth_engine_mp_tile" ); plod->setRange ( 1, 0, minRange ); #if USE_FILELOCATIONCALLBACK osgDB::Options* options = Registry::instance()->cloneOrCreateOptions(); options->setFileLocationCallback( new FileLocationCallback() ); plod->setDatabaseOptions( options ); #endif result = plod; // this one rejects back-facing tiles: if ( _frame.getMapInfo().isGeocentric() && _options.clusterCulling() == true ) { osg::HeightField* hf = model->_elevationData.getHeightField(); result->addCullCallback( HeightFieldUtils::createClusterCullingCallback( hf, tileNode->getKey().getProfile()->getSRS()->getEllipsoid(), *_options.verticalScale() ) ); } } else { result = tileNode; } return result; }
osg::BoundingSphered FeatureModelGraph::getBoundInWorldCoords( const GeoExtent& extent ) const { osg::Vec3d center, corner; GeoExtent workingExtent; if ( extent.getSRS()->isEquivalentTo( _usableMapExtent.getSRS() ) ) { workingExtent = extent; } else { workingExtent = extent.transform( _usableMapExtent.getSRS() ); // safe. } workingExtent.getCentroid( center.x(), center.y() ); corner.x() = workingExtent.xMin(); corner.y() = workingExtent.yMin(); if ( _session->getMapInfo().isGeocentric() ) { workingExtent.getSRS()->transformToECEF( center, center ); workingExtent.getSRS()->transformToECEF( corner, corner ); } return osg::BoundingSphered( center, (center-corner).length() ); }
void UnifiedCubeProfile::getIntersectingTiles(const GeoExtent& remoteExtent, unsigned localLOD, std::vector<TileKey>& out_intersectingKeys ) const { if ( getSRS()->isHorizEquivalentTo( remoteExtent.getSRS() ) ) { addIntersectingTiles( remoteExtent, localLOD, out_intersectingKeys ); } else { // the cube profile is non-contiguous. so there may be multiple local extents required // to fully intersect the remote extent. // first transform the remote extent to lat/long. GeoExtent remoteExtent_gcs = remoteExtent.getSRS()->isGeographic() ? remoteExtent : remoteExtent.transform( remoteExtent.getSRS()->getGeographicSRS() ); // Chop the input extent into three separate extents: for the equatorial, north polar, // and south polar tile regions. for( int face=0; face<6; ++face ) { GeoExtent partExtent_gcs = _faceExtent_gcs[face].intersectionSameSRS( remoteExtent_gcs ); if ( partExtent_gcs.isValid() ) { GeoExtent partExtent = transformGcsExtentOnFace( partExtent_gcs, face ); addIntersectingTiles( partExtent, localLOD, out_intersectingKeys ); } } } }
osg::Node* SerialKeyNodeFactory::createTile(TileModel* model, bool tileHasRealData) { // compile the model into a node: TileNode* tileNode = _modelCompiler->compile( model ); // see if this tile might have children. bool prepareForChildren = (tileHasRealData || (_options.minLOD().isSet() && model->_tileKey.getLOD() < *_options.minLOD())) && model->_tileKey.getLOD() < *_options.maxLOD(); osg::Node* result = 0L; if ( prepareForChildren ) { //Compute the min range based on the 2D size of the tile osg::BoundingSphere bs = tileNode->getBound(); GeoExtent extent = model->_tileKey.getExtent(); GeoPoint lowerLeft(extent.getSRS(), extent.xMin(), extent.yMin(), 0.0, ALTMODE_ABSOLUTE); GeoPoint upperRight(extent.getSRS(), extent.xMax(), extent.yMax(), 0.0, ALTMODE_ABSOLUTE); osg::Vec3d ll, ur; lowerLeft.toWorld( ll ); upperRight.toWorld( ur ); double radius = (ur - ll).length() / 2.0; float minRange = (float)(radius * _options.minTileRangeFactor().value()); osgDB::Options* dbOptions = Registry::instance()->cloneOrCreateOptions(); TileGroup* plod = new TileGroup(tileNode, _engineUID, _liveTiles.get(), _deadTiles.get(), dbOptions); plod->setSubtileRange( minRange ); #if USE_FILELOCATIONCALLBACK dbOptions->setFileLocationCallback( new FileLocationCallback() ); #endif result = plod; } else { result = tileNode; } // this one rejects back-facing tiles: if ( _mapInfo.isGeocentric() && _options.clusterCulling() == true ) { osg::HeightField* hf = model->_elevationData.getHeightField(); result->addCullCallback( HeightFieldUtils::createClusterCullingCallback( hf, tileNode->getKey().getProfile()->getSRS()->getEllipsoid(), *_options.verticalScale() ) ); } return result; }
osg::BoundingSphered FeatureModelGraph::getBoundInWorldCoords(const GeoExtent& extent, const MapFrame* mapf ) const { osg::Vec3d center, corner; GeoExtent workingExtent; if ( !extent.isValid() ) { return osg::BoundingSphered(); } if ( extent.getSRS()->isEquivalentTo( _usableMapExtent.getSRS() ) ) { workingExtent = extent; } else { workingExtent = extent.transform( _usableMapExtent.getSRS() ); // safe. } workingExtent.getCentroid( center.x(), center.y() ); double centerZ = 0.0; if ( mapf ) { // Use an appropriate resolution for this extents width double resolution = workingExtent.width(); ElevationQuery query( *mapf ); GeoPoint p( mapf->getProfile()->getSRS(), center, ALTMODE_ABSOLUTE ); query.getElevation( p, center.z(), resolution ); centerZ = center.z(); } corner.x() = workingExtent.xMin(); corner.y() = workingExtent.yMin(); corner.z() = 0; if ( _session->getMapInfo().isGeocentric() ) { const SpatialReference* ecefSRS = workingExtent.getSRS()->getECEF(); workingExtent.getSRS()->transform( center, ecefSRS, center ); workingExtent.getSRS()->transform( corner, ecefSRS, corner ); //workingExtent.getSRS()->transformToECEF( center, center ); //workingExtent.getSRS()->transformToECEF( corner, corner ); } if (workingExtent.getSRS()->isGeographic() && ( workingExtent.width() >= 90 || workingExtent.height() >= 90 ) ) { return osg::BoundingSphered( osg::Vec3d(0,0,0), 2*center.length() ); } return osg::BoundingSphered( center, (center-corner).length() ); }
void Profile::getIntersectingTiles(const GeoExtent& extent, unsigned localLOD, std::vector<TileKey>& out_intersectingKeys) const { GeoExtent ext = extent; // reproject into the profile's SRS if necessary: if ( !getSRS()->isHorizEquivalentTo( extent.getSRS() ) ) { // localize the extents and clamp them to legal values ext = clampAndTransformExtent( extent ); if ( !ext.isValid() ) return; } if ( ext.crossesAntimeridian() ) { GeoExtent first, second; if (ext.splitAcrossAntimeridian( first, second )) { addIntersectingTiles( first, localLOD, out_intersectingKeys ); addIntersectingTiles( second, localLOD, out_intersectingKeys ); } } else { addIntersectingTiles( ext, localLOD, out_intersectingKeys ); } }
osg::BoundingSphere SimplePager::getBounds(const TileKey& key) const { int samples = 6; GeoExtent extent = key.getExtent(); double xSample = extent.width() / (double)samples; double ySample = extent.height() / (double)samples; osg::BoundingSphere bs; for (int c = 0; c < samples+1; c++) { double x = extent.xMin() + (double)c * xSample; for (int r = 0; r < samples+1; r++) { double y = extent.yMin() + (double)r * ySample; osg::Vec3d world; GeoPoint samplePoint(extent.getSRS(), x, y, 0, ALTMODE_ABSOLUTE); GeoPoint wgs84 = samplePoint.transform(osgEarth::SpatialReference::create("epsg:4326")); wgs84.toWorld(world); bs.expandBy(world); } } return bs; }
bool VerticalDatum::transform(const VerticalDatum* from, const VerticalDatum* to, const GeoExtent& extent, osg::HeightField* hf ) { if ( from == to ) return true; unsigned cols = hf->getNumColumns(); unsigned rows = hf->getNumRows(); osg::Vec3d sw(extent.west(), extent.south(), 0.0); osg::Vec3d ne(extent.east(), extent.north(), 0.0); double xstep = abs(extent.east() - extent.west()) / double(cols-1); double ystep = abs(extent.north() - extent.south()) / double(rows-1); if ( !extent.getSRS()->isGeographic() ) { const SpatialReference* geoSRS = extent.getSRS()->getGeographicSRS(); extent.getSRS()->transform(sw, geoSRS, sw); extent.getSRS()->transform(ne, geoSRS, ne); xstep = (ne.x()-sw.x()) / double(cols-1); ystep = (ne.y()-sw.y()) / double(rows-1); } for( unsigned c=0; c<cols; ++c) { double lon = sw.x() + xstep*double(c); for( unsigned r=0; r<rows; ++r) { double lat = sw.y() + ystep*double(r); float& h = hf->getHeight(c, r); if (h != NO_DATA_VALUE) { VerticalDatum::transform( from, to, lat, lon, h ); } } } return true; }
osg::BoundingSphered FeatureModelGraph::getBoundInWorldCoords(const GeoExtent& extent, const MapFrame* mapf ) const { osg::Vec3d center, corner; //double z = 0.0; GeoExtent workingExtent; if ( extent.getSRS()->isEquivalentTo( _usableMapExtent.getSRS() ) ) { workingExtent = extent; } else { workingExtent = extent.transform( _usableMapExtent.getSRS() ); // safe. } workingExtent.getCentroid( center.x(), center.y() ); double centerZ = 0.0; if ( mapf ) { // Use an appropriate resolution for this extents width double resolution = workingExtent.width(); ElevationQuery query( *mapf ); query.getElevation( GeoPoint(mapf->getProfile()->getSRS(),center), center.z(), resolution ); centerZ = center.z(); } corner.x() = workingExtent.xMin(); corner.y() = workingExtent.yMin(); corner.z() = 0; if ( _session->getMapInfo().isGeocentric() ) { workingExtent.getSRS()->transformToECEF( center, center ); workingExtent.getSRS()->transformToECEF( corner, corner ); } return osg::BoundingSphered( center, (center-corner).length() ); }
void HeightFieldUtils::resolveInvalidHeights(osg::HeightField* grid, const GeoExtent& ex, float invalidValue, const Geoid* geoid) { if ( geoid ) { // need the lat/long extent for geoid queries: unsigned numRows = grid->getNumRows(); unsigned numCols = grid->getNumColumns(); GeoExtent geodeticExtent = ex.getSRS()->isGeographic() ? ex : ex.transform( ex.getSRS()->getGeographicSRS() ); double latMin = geodeticExtent.yMin(); double lonMin = geodeticExtent.xMin(); double lonInterval = geodeticExtent.width() / (double)(numCols-1); double latInterval = geodeticExtent.height() / (double)(numRows-1); for( unsigned r=0; r<numRows; ++r ) { double lat = latMin + latInterval*(double)r; for( unsigned c=0; c<numCols; ++c ) { double lon = lonMin + lonInterval*(double)c; if ( grid->getHeight(c, r) == invalidValue ) { grid->setHeight( c, r, geoid->getHeight(lat, lon) ); } } } } else { for(unsigned int i=0; i<grid->getHeightList().size(); i++ ) { if ( grid->getHeightList()[i] == invalidValue ) { grid->getHeightList()[i] = 0.0; } } } }
GeoImage GeoImage::crop( const GeoExtent& extent, bool exact, unsigned int width, unsigned int height ) const { //Check for equivalence if ( extent.getSRS()->isEquivalentTo( getSRS() ) ) { //If we want an exact crop or they want to specify the output size of the image, use GDAL if (exact || width != 0 || height != 0 ) { OE_DEBUG << "[osgEarth::GeoImage::crop] Performing exact crop" << std::endl; //Suggest an output image size if (width == 0 || height == 0) { double xRes = (getExtent().xMax() - getExtent().xMin()) / (double)_image->s(); double yRes = (getExtent().yMax() - getExtent().yMin()) / (double)_image->t(); width = osg::maximum(1u, (unsigned int)((extent.xMax() - extent.xMin()) / xRes)); height = osg::maximum(1u, (unsigned int)((extent.yMax() - extent.yMin()) / yRes)); OE_DEBUG << "[osgEarth::GeoImage::crop] Computed output image size " << width << "x" << height << std::endl; } //Note: Passing in the current SRS simply forces GDAL to not do any warping return reproject( getSRS(), &extent, width, height); } else { OE_DEBUG << "[osgEarth::GeoImage::crop] Performing non-exact crop " << std::endl; //If an exact crop is not desired, we can use the faster image cropping code that does no resampling. double destXMin = extent.xMin(); double destYMin = extent.yMin(); double destXMax = extent.xMax(); double destYMax = extent.yMax(); osg::Image* new_image = ImageUtils::cropImage( _image.get(), _extent.xMin(), _extent.yMin(), _extent.xMax(), _extent.yMax(), destXMin, destYMin, destXMax, destYMax ); //The destination extents may be different than the input extents due to not being able to crop along pixel boundaries. return new_image? GeoImage( new_image, GeoExtent( getSRS(), destXMin, destYMin, destXMax, destYMax ) ) : GeoImage::INVALID; } } else { //TODO: just reproject the image before cropping OE_NOTICE << "[osgEarth::GeoImage::crop] Cropping extent does not have equivalent SpatialReference" << std::endl; return GeoImage::INVALID; } }
void MPTerrainEngineNode::invalidateRegion(const GeoExtent& extent, unsigned minLevel, unsigned maxLevel) { if (_terrainOptions.incrementalUpdate() == true && _liveTiles.valid()) { GeoExtent extentLocal = extent; if ( !extent.getSRS()->isEquivalentTo(this->getMap()->getSRS()) ) { extent.transform(this->getMap()->getSRS(), extentLocal); } _liveTiles->setDirty(extentLocal, minLevel, maxLevel); } }
GeoExtent Profile::clampAndTransformExtent( const GeoExtent& input, bool* out_clamped ) const { if ( out_clamped ) *out_clamped = false; // do the clamping in LAT/LONG. const SpatialReference* geo_srs = getSRS()->getGeographicSRS(); // get the input in lat/long: GeoExtent gcs_input = input.getSRS()->isGeographic()? input : input.transform( geo_srs ); // bail out on a bad transform: if ( !gcs_input.isValid() ) return GeoExtent::INVALID; // bail out if the extent's do not intersect at all: if ( !gcs_input.intersects(_latlong_extent, false) ) return GeoExtent::INVALID; // clamp it to the profile's extents: GeoExtent clamped_gcs_input = GeoExtent( gcs_input.getSRS(), osg::clampBetween( gcs_input.xMin(), _latlong_extent.xMin(), _latlong_extent.xMax() ), osg::clampBetween( gcs_input.yMin(), _latlong_extent.yMin(), _latlong_extent.yMax() ), osg::clampBetween( gcs_input.xMax(), _latlong_extent.xMin(), _latlong_extent.xMax() ), osg::clampBetween( gcs_input.yMax(), _latlong_extent.yMin(), _latlong_extent.yMax() ) ); if ( out_clamped ) *out_clamped = (clamped_gcs_input != gcs_input); // finally, transform the clamped extent into this profile's SRS and return it. GeoExtent result = clamped_gcs_input.getSRS()->isEquivalentTo( this->getSRS() )? clamped_gcs_input : clamped_gcs_input.transform( this->getSRS() ); if (result.isValid()) { OE_DEBUG << LC << "clamp&xform: input=" << input.toString() << ", output=" << result.toString() << std::endl; } return result; }
bool TileIndex::add( const std::string& filename, const GeoExtent& extent ) { osg::ref_ptr< Polygon > polygon = new Polygon(); polygon->push_back( osg::Vec3d(extent.bounds().xMin(), extent.bounds().yMin(), 0) ); polygon->push_back( osg::Vec3d(extent.bounds().xMax(), extent.bounds().yMin(), 0) ); polygon->push_back( osg::Vec3d(extent.bounds().xMax(), extent.bounds().yMax(), 0) ); polygon->push_back( osg::Vec3d(extent.bounds().xMin(), extent.bounds().yMax(), 0) ); polygon->push_back( osg::Vec3d(extent.bounds().xMin(), extent.bounds().yMin(), 0) ); osg::ref_ptr< Feature > feature = new Feature( polygon.get(), extent.getSRS() ); feature->set("location", filename ); const SpatialReference* wgs84 = SpatialReference::create("epsg:4326"); feature->transform( wgs84 ); return _features->insertFeature( feature.get() ); return true; }
bool TerrainLayer::mayHaveDataInExtent(const GeoExtent& ex) const { if (!ex.isValid()) { // bad extent; no data return false; } const DataExtentList& de = getDataExtents(); if (de.empty()) { // not enough info, assume yes return true; } // Get extent in local profile: GeoExtent localExtent = ex; if (getProfile() && getProfile()->getSRS()->isHorizEquivalentTo(ex.getSRS())) { localExtent = getProfile()->clampAndTransformExtent(ex); } // Check union: if (getDataExtentsUnion().intersects(localExtent)) { // possible yes return true; } // Check each extent in turn: for (DataExtentList::const_iterator i = de.begin(); i != de.end(); ++i) { if (i->intersects(localExtent)) { // possible yes return true; } } // definite no. return false; }
TileNode* TileGroupFactory::createTileNodeGraph(TerrainTileModel* model, bool setupChildrenIfNecessary, ProgressCallback* progress) { // TODO: fix this const unsigned tileSize = 17; // Build the surface node. SurfaceNodeFactory factory(model, _frame, _renderBindings, _geometryPool, tileSize, _options); SurfaceNode* surfaceNode = factory.createSurfaceNode(); surfaceNode->setEngineUID( _terrainEngine->getUID() ); // see if this tile might have children. bool prepareForChildren = setupChildrenIfNecessary && model->getKey().getLOD() < *_options.maxLOD(); // Build the Tile Node that will hold all the textures and texture matrices. TileNode* tileNode = createTileNode( model, progress ); // Build the paging node that will load subtiles, if necessary: if ( prepareForChildren ) { osg::BoundingSphere bs = surfaceNode->getBound(); TilePagedLOD* plod = new TilePagedLOD( _terrainEngine->getUID(), _liveTiles, _deadTiles ); plod->setCenter ( bs.center() ); plod->addChild ( surfaceNode ); plod->setFileName( 1, Stringify() << model->getKey().str() << "." << _terrainEngine->getUID() << ".osgearth_engine_mp_tile" ); if ( _options.rangeMode().value() == osg::LOD::DISTANCE_FROM_EYE_POINT ) { //Compute the min range based on the 2D size of the tile GeoExtent extent = model->getKey().getExtent(); GeoPoint lowerLeft(extent.getSRS(), extent.xMin(), extent.yMin(), 0.0, ALTMODE_ABSOLUTE); GeoPoint upperRight(extent.getSRS(), extent.xMax(), extent.yMax(), 0.0, ALTMODE_ABSOLUTE); osg::Vec3d ll, ur; lowerLeft.toWorld( ll ); upperRight.toWorld( ur ); double radius = (ur - ll).length() / 2.0; float minRange = (float)(radius * _options.minTileRangeFactor().value()); plod->setRange( 0, minRange, FLT_MAX ); plod->setRange( 1, 0, minRange ); plod->setRangeMode( osg::LOD::DISTANCE_FROM_EYE_POINT ); } else { plod->setRange( 0, 0.0f, _options.tilePixelSize().value() ); plod->setRange( 1, _options.tilePixelSize().value(), FLT_MAX ); plod->setRangeMode( osg::LOD::PIXEL_SIZE_ON_SCREEN ); } #if 0 // TODO: reinstate this! // Install a tile-aligned bounding box in the pager node itself so we can do // visibility testing before paging in subtiles. plod->setChildBoundingBoxAndMatrix( 1, surfaceNode->getTerrainBoundingBox(), surfaceNode->getLocalToWorldMatrix() ); #endif #if USE_FILELOCATIONCALLBACK osgDB::Options* options = plod->getOrCreateDBOptions(); options->setFileLocationCallback( new FileLocationCallback() ); #endif tileNode->addChild( plod ); // Install a callback to reject back-facing tiles. if ( _frame.getMapInfo().isGeocentric() && _options.clusterCulling() == true ) { const osg::HeightField* heightField = model->elevationModel()->getHeightField(); if ( heightField ) { tileNode->addCullCallback( HeightFieldUtils::createClusterCullingCallback( heightField, tileNode->getKey().getProfile()->getSRS()->getEllipsoid(), *_options.verticalScale() ) ); } } } else { tileNode->addChild( surfaceNode ); } return tileNode; }
void SerialKeyNodeFactory::addTile(TileModel* model, bool tileHasRealData, bool tileHasLodBlending, osg::Group* parent ) { // create a node: TileNode* tileNode = new TileNode( model->_tileKey, model->_tileLocator ); // install the tile model and compile it: tileNode->setTileModel( model ); tileNode->compile( _modelCompiler.get() ); // assemble a URI for this tile's child group: std::string uri = Stringify() << model->_tileKey.str() << "." << _engineUID << ".osgearth_engine_mp_tile"; osg::Node* result = 0L; // Only add the next tile if all the following are true: // 1. Either there's real tile data, or a minLOD is explicity set in the options; // 2. The tile isn't blacklisted; and // 3. We are still below the maximim LOD. bool wrapInPagedLOD = (tileHasRealData || (_options.minLOD().isSet() && model->_tileKey.getLOD() < *_options.minLOD())) && !osgEarth::Registry::instance()->isBlacklisted( uri ) && model->_tileKey.getLOD() < *_options.maxLOD(); if ( wrapInPagedLOD ) { osg::BoundingSphere bs = tileNode->getBound(); float maxRange = FLT_MAX; //Compute the min range based on the 2D size of the tile GeoExtent extent = model->_tileKey.getExtent(); GeoPoint lowerLeft(extent.getSRS(), extent.xMin(), extent.yMin(), 0.0, ALTMODE_ABSOLUTE); GeoPoint upperRight(extent.getSRS(), extent.xMax(), extent.yMax(), 0.0, ALTMODE_ABSOLUTE); osg::Vec3d ll, ur; lowerLeft.toWorld( ll ); upperRight.toWorld( ur ); double radius = (ur - ll).length() / 2.0; float minRange = (float)(radius * _options.minTileRangeFactor().value()); // create a PLOD so we can keep subdividing: osg::PagedLOD* plod = new CustomPagedLOD( _liveTiles.get(), _deadTiles.get() ); plod->setCenter( bs.center() ); plod->addChild( tileNode ); plod->setRangeMode( *_options.rangeMode() ); plod->setFileName( 1, uri ); if (plod->getRangeMode() == osg::LOD::PIXEL_SIZE_ON_SCREEN) { static const float sqrt2 = sqrt(2.0f); minRange = 0; maxRange = (*_options.tilePixelSize()) * sqrt2; plod->setRange( 0, minRange, maxRange ); plod->setRange( 1, maxRange, FLT_MAX ); } else { plod->setRange( 0, minRange, maxRange ); plod->setRange( 1, 0, minRange ); } plod->setUserData( new MapNode::TileRangeData(minRange, maxRange) ); #if USE_FILELOCATIONCALLBACK osgDB::Options* options = Registry::instance()->cloneOrCreateOptions(); options->setFileLocationCallback( new FileLocationCallback() ); plod->setDatabaseOptions( options ); #endif result = plod; if ( tileHasLodBlending ) { // Make the LOD transition distance, and a measure of how // close the tile is to an LOD change, to shaders. result->addCullCallback(new LODFactorCallback); } } else { result = tileNode; } // this cull callback dynamically adjusts the LOD scale based on distance-to-camera: if ( _options.lodFallOff().isSet() && *_options.lodFallOff() > 0.0 ) { result->addCullCallback( new DynamicLODScaleCallback(*_options.lodFallOff()) ); } // this one rejects back-facing tiles: if ( _mapInfo.isGeocentric() && _options.clusterCulling() == true ) { osg::HeightField* hf = model->_elevationData.getHFLayer()->getHeightField(); result->addCullCallback( HeightFieldUtils::createClusterCullingCallback( hf, tileNode->getLocator()->getEllipsoidModel(), *_options.verticalScale() ) ); } parent->addChild( result ); }
void SerialKeyNodeFactory::addTile(Tile* tile, bool tileHasRealData, bool tileHasLodBlending, osg::Group* parent ) { // associate this tile with the terrain: tile->setTerrainTechnique( _terrain->cloneTechnique() ); tile->attachToTerrain( _terrain ); // assemble a URI for this tile's child group: std::stringstream buf; buf << tile->getKey().str() << "." << _engineUID << ".osgearth_osgterrain_tile"; std::string uri; uri = buf.str(); osg::Node* result = 0L; // Only add the next tile if all the following are true: // 1. Either there's real tile data, or a maxLOD is explicity set in the options; // 2. The tile isn't blacklisted; and // 3. We are still below the max LOD. bool wrapInPagedLOD = (tileHasRealData || _options.maxLOD().isSet()) && !osgEarth::Registry::instance()->isBlacklisted( uri ) && tile->getKey().getLevelOfDetail() < (unsigned)*_options.maxLOD(); if ( wrapInPagedLOD ) { osg::BoundingSphere bs = tile->getBound(); double maxRange = 1e10; #if 0 //Compute the min range based on the actual bounds of the tile. This can break down if you have very high resolution //data with elevation variations and you can run out of memory b/c the elevation change is greater than the actual size of the tile so you end up //inifinitely subdividing (or at least until you run out of data or memory) double minRange = bs.radius() * _options.minTileRangeFactor().value(); #else //double origMinRange = bs.radius() * _options.minTileRangeFactor().value(); //Compute the min range based on the 2D size of the tile GeoExtent extent = tile->getKey().getExtent(); GeoPoint lowerLeft(extent.getSRS(), extent.xMin(), extent.yMin()); GeoPoint upperRight(extent.getSRS(), extent.xMax(), extent.yMax()); osg::Vec3d ll, ur; lowerLeft.toWorld( ll ); upperRight.toWorld( ur ); double radius = (ur - ll).length() / 2.0; double minRange = radius * _options.minTileRangeFactor().value(); #endif // create a PLOD so we can keep subdividing: osg::PagedLOD* plod = new osg::PagedLOD(); plod->setCenter( bs.center() ); plod->addChild( tile, minRange, maxRange ); plod->setFileName( 1, uri ); plod->setRange ( 1, 0, minRange ); plod->setUserData( new MapNode::TileRangeData(minRange, maxRange) ); #if USE_FILELOCATIONCALLBACK osgDB::Options* options = Registry::instance()->cloneOrCreateOptions(); options->setFileLocationCallback( new FileLocationCallback() ); plod->setDatabaseOptions( options ); #endif result = plod; if ( tileHasLodBlending ) { // Make the LOD transition distance, and a measure of how // close the tile is to an LOD change, to shaders. result->addCullCallback(new Drivers::LODFactorCallback); } } else { result = tile; } // this cull callback dynamically adjusts the LOD scale based on distance-to-camera: if ( _options.lodFallOff().isSet() && *_options.lodFallOff() > 0.0 ) { result->addCullCallback( new DynamicLODScaleCallback(*_options.lodFallOff()) ); } // this one rejects back-facing tiles: if ( _mapInfo.isGeocentric() && _options.clusterCulling() == true ) { result->addCullCallback( HeightFieldUtils::createClusterCullingCallback( static_cast<osgTerrain::HeightFieldLayer*>(tile->getElevationLayer())->getHeightField(), tile->getLocator()->getEllipsoidModel(), tile->getVerticalScale() ) ); } parent->addChild( result ); }
osg::Node* SingleKeyNodeFactory::createTile(TileModel* model, bool setupChildrenIfNecessary, ProgressCallback* progress) { #ifdef EXPERIMENTAL_TILE_NODE_CACHE osg::ref_ptr<TileNode> tileNode; TileNodeCache::Record rec; cache.get(model->_tileKey, rec); if ( rec.valid() ) { tileNode = rec.value().get(); } else { tileNode = _modelCompiler->compile( model, _frame ); cache.insert(model->_tileKey, tileNode); } #else // compile the model into a node: osg::ref_ptr<TileNode> tileNode = _modelCompiler->compile(model, _frame, progress); #endif // see if this tile might have children. bool prepareForChildren = setupChildrenIfNecessary && model->_tileKey.getLOD() < *_options.maxLOD(); osg::Node* result = 0L; if ( prepareForChildren ) { osg::BoundingSphere bs = tileNode->getBound(); TilePagedLOD* plod = new TilePagedLOD( _engine->getUID(), _liveTiles.get(), _releaser.get() ); plod->setCenter ( bs.center() ); plod->addChild ( tileNode.get() ); plod->setFileName( 1, Stringify() << tileNode->getKey().str() << "." << _engine->getUID() << ".osgearth_engine_mp_tile" ); double rangeFactor = _options.minTileRangeFactor().get(); //if (_options.adaptivePolarRangeFactor() == true) //{ // double lat = model->_tileKey.getExtent().yMin() < 0 ? -model->_tileKey.getExtent().yMax() : model->_tileKey.getExtent().yMin(); // double latRad = osg::DegreesToRadians(lat); // rangeFactor -= (rangeFactor - 1.0)*sin(latRad)*sin(latRad); //} plod->setRangeFactor(rangeFactor); // Setup expiration. if (_options.minExpiryFrames().isSet()) { plod->setMinimumExpiryFrames(1, *_options.minExpiryFrames()); } if (_options.minExpiryTime().isSet()) { plod->setMinimumExpiryTime(1, *_options.minExpiryTime()); } if ( _options.rangeMode().value() == osg::LOD::DISTANCE_FROM_EYE_POINT ) { //Compute the min range based on the 2D size of the tile GeoExtent extent = model->_tileKey.getExtent(); double radius = 0.0; GeoPoint lowerLeft(extent.getSRS(), extent.xMin(), extent.yMin(), 0.0, ALTMODE_ABSOLUTE); GeoPoint upperRight(extent.getSRS(), extent.xMax(), extent.yMax(), 0.0, ALTMODE_ABSOLUTE); osg::Vec3d ll, ur; lowerLeft.toWorld( ll ); upperRight.toWorld( ur ); double radiusDiag = (ur - ll).length() / 2.0; if (_options.adaptivePolarRangeFactor() == true ) { GeoPoint left(extent.getSRS(), extent.xMin(), extent.yMin()+extent.height()*0.5, 0.0, ALTMODE_ABSOLUTE); GeoPoint right(extent.getSRS(), extent.xMax(), extent.yMin()+extent.height()*0.5, 0.0, ALTMODE_ABSOLUTE); osg::Vec3d l, r; left.toWorld(l); right.toWorld(r); double radiusHoriz = 1.4142 * (r - l).length() / 2.0; double lat = model->_tileKey.getExtent().yMin() < 0 ? -model->_tileKey.getExtent().yMax() : model->_tileKey.getExtent().yMin(); double latRad = osg::DegreesToRadians(lat); // mix between diagonal radius and horizontal radius based on latitude double t = cos(latRad); t = 1.0-(1.0-t)*(1.0-t); // decelerate t to weight the mix in favor of equator (diag radius) radius = t*radiusDiag + (1.0-t)*radiusHoriz; } else { radius = radiusDiag; } float minRange = radius; plod->setRange( 0, minRange, FLT_MAX ); plod->setRange( 1, 0, minRange ); plod->setRangeMode( osg::LOD::DISTANCE_FROM_EYE_POINT ); } else { // the *2 is because we page in 4-tile sets, not individual tiles. float size = 2.0f * _options.tilePixelSize().value(); plod->setRange( 0, 0.0f, size ); plod->setRange( 1, size, FLT_MAX ); plod->setRangeMode( osg::LOD::PIXEL_SIZE_ON_SCREEN ); } // Install a tile-aligned bounding box in the pager node itself so we can do // visibility testing before paging in subtiles. plod->setChildBoundingBoxAndMatrix( 1, tileNode->getTerrainBoundingBox(), tileNode->getMatrix() ); // DBPager will set a priority based on the ratio range/maxRange. // This will offset that number with a full LOD #, giving LOD precedence. // Experimental. //plod->setPriorityScale( 1, model->_tileKey.getLOD()+1 ); #if USE_FILELOCATIONCALLBACK osgDB::Options* options = plod->getOrCreateDBOptions(); options->setFileLocationCallback( new FileLocationCallback() ); #endif result = plod; // this one rejects back-facing tiles: if ( _frame.getMapInfo().isGeocentric() && _options.clusterCulling() == true ) { osg::HeightField* hf = model->_elevationData.getHeightField(); result->addCullCallback( HeightFieldUtils::createClusterCullingCallback( hf, tileNode->getKey().getProfile()->getSRS()->getEllipsoid(), *_options.verticalScale() ) ); } } else { result = tileNode.release(); } return result; }
void Profile::addIntersectingTiles(const GeoExtent& key_ext, unsigned localLOD, std::vector<TileKey>& out_intersectingKeys) const { // assume a non-crossing extent here. if ( key_ext.crossesAntimeridian() ) { OE_WARN << "Profile::addIntersectingTiles cannot process date-line cross" << std::endl; return; } int tileMinX, tileMaxX; int tileMinY, tileMaxY; // Special path for mercator (does NOT work for cube, e.g.) if ( key_ext.getSRS()->isMercator() ) { int precision = 5; double eps = 0.001; double keyWidth = round(key_ext.width(), precision); int destLOD = 0; double w, h; getTileDimensions(0, w, h); for(; (round(w,precision) - keyWidth) > eps; w*=0.5, h*=0.5, destLOD++ ); double destTileWidth, destTileHeight; getTileDimensions( destLOD, destTileWidth, destTileHeight ); destTileWidth = round(destTileWidth, precision); destTileHeight = round(destTileHeight, precision); tileMinX = quantize( ((key_ext.xMin() - _extent.xMin()) / destTileWidth), eps ); tileMaxX = (int)((key_ext.xMax() - _extent.xMin()) / destTileWidth); tileMinY = quantize( ((_extent.yMax() - key_ext.yMax()) / destTileHeight), eps ); tileMaxY = (int) ((_extent.yMax() - key_ext.yMin()) / destTileHeight); } else { double destTileWidth, destTileHeight; getTileDimensions(localLOD, destTileWidth, destTileHeight); //OE_DEBUG << std::fixed << " Source Tile: " << key.getLevelOfDetail() << " (" << keyWidth << ", " << keyHeight << ")" << std::endl; //OE_DEBUG << std::fixed << " Dest Size: " << destLOD << " (" << destTileWidth << ", " << destTileHeight << ")" << std::endl; tileMinX = (int)((key_ext.xMin() - _extent.xMin()) / destTileWidth); tileMaxX = (int)((key_ext.xMax() - _extent.xMin()) / destTileWidth); tileMinY = (int)((_extent.yMax() - key_ext.yMax()) / destTileHeight); tileMaxY = (int)((_extent.yMax() - key_ext.yMin()) / destTileHeight); } unsigned int numWide, numHigh; getNumTiles(localLOD, numWide, numHigh); // bail out if the tiles are out of bounds. if ( tileMinX >= (int)numWide || tileMinY >= (int)numHigh || tileMaxX < 0 || tileMaxY < 0 ) { return; } tileMinX = osg::clampBetween(tileMinX, 0, (int)numWide-1); tileMaxX = osg::clampBetween(tileMaxX, 0, (int)numWide-1); tileMinY = osg::clampBetween(tileMinY, 0, (int)numHigh-1); tileMaxY = osg::clampBetween(tileMaxY, 0, (int)numHigh-1); OE_DEBUG << std::fixed << " Dest Tiles: " << tileMinX << "," << tileMinY << " => " << tileMaxX << "," << tileMaxY << std::endl; for (int i = tileMinX; i <= tileMaxX; ++i) { for (int j = tileMinY; j <= tileMaxY; ++j) { //TODO: does not support multi-face destination keys. out_intersectingKeys.push_back( TileKey(localLOD, i, j, this) ); } } }
//override bool renderFeaturesForStyle( const Style& style, const FeatureList& inFeatures, osg::Referenced* buildData, const GeoExtent& imageExtent, osg::Image* image ) { // local copy of the features that we can process FeatureList features = inFeatures; BuildData* bd = static_cast<BuildData*>( buildData ); // A processing context to use with the filters: FilterContext context; context.profile() = getFeatureSource()->getFeatureProfile(); const LineSymbol* masterLine = style.getSymbol<LineSymbol>(); const PolygonSymbol* masterPoly = style.getSymbol<PolygonSymbol>(); //bool embeddedStyles = getFeatureSource()->hasEmbeddedStyles(); // if only a line symbol exists, and there are polygons in the mix, draw them // as outlines (line rings). //OE_INFO << LC << "Line Symbol = " << (masterLine == 0L ? "null" : masterLine->getConfig().toString()) << std::endl; //OE_INFO << LC << "Poly SYmbol = " << (masterPoly == 0L ? "null" : masterPoly->getConfig().toString()) << std::endl; //bool convertPolysToRings = poly == 0L && line != 0L; //if ( convertPolysToRings ) // OE_INFO << LC << "No PolygonSymbol; will draw polygons to rings" << std::endl; // initialize: double xmin = imageExtent.xMin(); double ymin = imageExtent.yMin(); //double s = (double)image->s(); //double t = (double)image->t(); double xf = (double)image->s() / imageExtent.width(); double yf = (double)image->t() / imageExtent.height(); // strictly speaking we should iterate over the features and buffer each one that's a line, // rather then checking for the existence of a LineSymbol. FeatureList linesToBuffer; for(FeatureList::iterator i = features.begin(); i != features.end(); i++) { Feature* feature = i->get(); Geometry* geom = feature->getGeometry(); if ( geom ) { // check for an embedded style: const LineSymbol* line = feature->style().isSet() ? feature->style()->getSymbol<LineSymbol>() : masterLine; const PolygonSymbol* poly = feature->style().isSet() ? feature->style()->getSymbol<PolygonSymbol>() : masterPoly; // if we have polygons but only a LineSymbol, draw the poly as a line. if ( geom->getComponentType() == Geometry::TYPE_POLYGON ) { if ( !poly && line ) { Feature* outline = new Feature( *feature ); geom = geom->cloneAs( Geometry::TYPE_RING ); outline->setGeometry( geom ); *i = outline; feature = outline; } //TODO: fix to enable outlined polys. doesn't work, not sure why -gw //else if ( poly && line ) //{ // Feature* outline = new Feature(); // geom = geom->cloneAs( Geometry::TYPE_LINESTRING ); // outline->setGeometry( geom ); // features.push_back( outline ); //} } bool needsBuffering = geom->getComponentType() == Geometry::TYPE_LINESTRING || geom->getComponentType() == Geometry::TYPE_RING; if ( needsBuffering ) { linesToBuffer.push_back( feature ); } } } if ( linesToBuffer.size() > 0 ) { //We are buffering in the features native extent, so we need to use the transform extent to get the proper "resolution" for the image GeoExtent transformedExtent = imageExtent.transform(context.profile()->getSRS()); double trans_xf = (double)image->s() / transformedExtent.width(); double trans_yf = (double)image->t() / transformedExtent.height(); // resolution of the image (pixel extents): double xres = 1.0/trans_xf; double yres = 1.0/trans_yf; // downsample the line data so that it is no higher resolution than to image to which // we intend to rasterize it. If you don't do this, you run the risk of the buffer // operation taking forever on very high-res input data. if ( _options.optimizeLineSampling() == true ) { ResampleFilter resample; resample.minLength() = osg::minimum( xres, yres ); context = resample.push( linesToBuffer, context ); } // now run the buffer operation on all lines: BufferFilter buffer; float lineWidth = 0.5; if ( masterLine ) { buffer.capStyle() = masterLine->stroke()->lineCap().value(); if ( masterLine->stroke()->width().isSet() ) lineWidth = masterLine->stroke()->width().value(); } // "relative line size" means that the line width is expressed in (approx) pixels // rather than in map units if ( _options.relativeLineSize() == true ) buffer.distance() = xres * lineWidth; else buffer.distance() = lineWidth; buffer.push( linesToBuffer, context ); } // First, transform the features into the map's SRS: TransformFilter xform( imageExtent.getSRS() ); xform.setLocalizeCoordinates( false ); context = xform.push( features, context ); // set up the AGG renderer: agg::rendering_buffer rbuf( image->data(), image->s(), image->t(), image->s()*4 ); // Create the renderer and the rasterizer agg::renderer<agg::span_abgr32> ren(rbuf); agg::rasterizer ras; // Setup the rasterizer ras.gamma(1.3); ras.filling_rule(agg::fill_even_odd); GeoExtent cropExtent = GeoExtent(imageExtent); cropExtent.scale(1.1, 1.1); osg::ref_ptr<Symbology::Polygon> cropPoly = new Symbology::Polygon( 4 ); cropPoly->push_back( osg::Vec3d( cropExtent.xMin(), cropExtent.yMin(), 0 )); cropPoly->push_back( osg::Vec3d( cropExtent.xMax(), cropExtent.yMin(), 0 )); cropPoly->push_back( osg::Vec3d( cropExtent.xMax(), cropExtent.yMax(), 0 )); cropPoly->push_back( osg::Vec3d( cropExtent.xMin(), cropExtent.yMax(), 0 )); double lineWidth = 1.0; if ( masterLine ) lineWidth = (double)masterLine->stroke()->width().value(); osg::Vec4 color = osg::Vec4(1, 1, 1, 1); if ( masterLine ) color = masterLine->stroke()->color(); // render the features for(FeatureList::iterator i = features.begin(); i != features.end(); i++) { Feature* feature = i->get(); //bool first = bd->_pass == 0 && i == features.begin(); Geometry* geometry = feature->getGeometry(); osg::ref_ptr< Geometry > croppedGeometry; if ( ! geometry->crop( cropPoly.get(), croppedGeometry ) ) continue; // set up a default color: osg::Vec4 c = color; unsigned int a = (unsigned int)(127+(c.a()*255)/2); // scale alpha up agg::rgba8 fgColor( (unsigned int)(c.r()*255), (unsigned int)(c.g()*255), (unsigned int)(c.b()*255), a ); GeometryIterator gi( croppedGeometry.get() ); while( gi.hasMore() ) { c = color; Geometry* g = gi.next(); const LineSymbol* line = feature->style().isSet() ? feature->style()->getSymbol<LineSymbol>() : masterLine; const PolygonSymbol* poly = feature->style().isSet() ? feature->style()->getSymbol<PolygonSymbol>() : masterPoly; if (g->getType() == Geometry::TYPE_RING || g->getType() == Geometry::TYPE_LINESTRING) { if ( line ) c = line->stroke()->color(); else if ( poly ) c = poly->fill()->color(); } else if ( g->getType() == Geometry::TYPE_POLYGON ) { if ( poly ) c = poly->fill()->color(); else if ( line ) c = line->stroke()->color(); } a = (unsigned int)(127+(c.a()*255)/2); // scale alpha up fgColor = agg::rgba8( (unsigned int)(c.r()*255), (unsigned int)(c.g()*255), (unsigned int)(c.b()*255), a ); ras.filling_rule( agg::fill_even_odd ); for( Geometry::iterator p = g->begin(); p != g->end(); p++ ) { const osg::Vec3d& p0 = *p; double x0 = xf*(p0.x()-xmin); double y0 = yf*(p0.y()-ymin); //const osg::Vec3d& p1 = p+1 != g->end()? *(p+1) : g->front(); //double x1 = xf*(p1.x()-xmin); //double y1 = yf*(p1.y()-ymin); if ( p == g->begin() ) ras.move_to_d( x0, y0 ); else ras.line_to_d( x0, y0 ); } } ras.render(ren, fgColor); ras.reset(); } bd->_pass++; return true; }
osg::Node* SingleKeyNodeFactory::createTile(TileModel* model, bool setupChildrenIfNecessary, ProgressCallback* progress) { #ifdef EXPERIMENTAL_TILE_NODE_CACHE osg::ref_ptr<TileNode> tileNode; TileNodeCache::Record rec; cache.get(model->_tileKey, rec); if ( rec.valid() ) { tileNode = rec.value().get(); } else { tileNode = _modelCompiler->compile( model, _frame ); cache.insert(model->_tileKey, tileNode); } #else // compile the model into a node: TileNode* tileNode = _modelCompiler->compile(model, _frame, progress); #endif // see if this tile might have children. bool prepareForChildren = setupChildrenIfNecessary && model->_tileKey.getLOD() < *_options.maxLOD(); osg::Node* result = 0L; if ( prepareForChildren ) { osg::BoundingSphere bs = tileNode->getBound(); TilePagedLOD* plod = new TilePagedLOD( _engineUID, _liveTiles, _deadTiles ); plod->setCenter ( bs.center() ); plod->addChild ( tileNode ); plod->setFileName( 1, Stringify() << tileNode->getKey().str() << "." << _engineUID << ".osgearth_engine_mp_tile" ); if ( _options.rangeMode().value() == osg::LOD::DISTANCE_FROM_EYE_POINT ) { //Compute the min range based on the 2D size of the tile GeoExtent extent = model->_tileKey.getExtent(); GeoPoint lowerLeft(extent.getSRS(), extent.xMin(), extent.yMin(), 0.0, ALTMODE_ABSOLUTE); GeoPoint upperRight(extent.getSRS(), extent.xMax(), extent.yMax(), 0.0, ALTMODE_ABSOLUTE); osg::Vec3d ll, ur; lowerLeft.toWorld( ll ); upperRight.toWorld( ur ); double radius = (ur - ll).length() / 2.0; float minRange = (float)(radius * _options.minTileRangeFactor().value()); plod->setRange( 0, minRange, FLT_MAX ); plod->setRange( 1, 0, minRange ); plod->setRangeMode( osg::LOD::DISTANCE_FROM_EYE_POINT ); } else { plod->setRange( 0, 0.0f, _options.tilePixelSize().value() ); plod->setRange( 1, _options.tilePixelSize().value(), FLT_MAX ); plod->setRangeMode( osg::LOD::PIXEL_SIZE_ON_SCREEN ); } // DBPager will set a priority based on the ratio range/maxRange. // This will offset that number with a full LOD #, giving LOD precedence. // Experimental. //plod->setPriorityScale( 1, model->_tileKey.getLOD()+1 ); #if USE_FILELOCATIONCALLBACK osgDB::Options* options = plod->getOrCreateDBOptions(); options->setFileLocationCallback( new FileLocationCallback() ); #endif result = plod; // this one rejects back-facing tiles: if ( _frame.getMapInfo().isGeocentric() && _options.clusterCulling() == true ) { osg::HeightField* hf = model->_elevationData.getHeightField(); result->addCullCallback( HeightFieldUtils::createClusterCullingCallback( hf, tileNode->getKey().getProfile()->getSRS()->getEllipsoid(), *_options.verticalScale() ) ); } } else { result = tileNode; } return result; }
void execute() { GeoImage geoImage; bool isFallbackData = false; bool useMercatorFastPath = _opt->enableMercatorFastPath() != false && _mapInfo->isGeocentric() && _layer->getProfile() && _layer->getProfile()->getSRS()->isSphericalMercator(); // fetch the image from the layer, falling back on parent keys utils we are // able to find one that works. bool autoFallback = _key.getLevelOfDetail() <= 1; TileKey imageKey( _key ); TileSource* tileSource = _layer->getTileSource(); const Profile* layerProfile = _layer->getProfile(); //Only try to get data from the source if it actually intersects the key extent bool hasDataInExtent = true; if (tileSource && layerProfile) { GeoExtent ext = _key.getExtent(); if (!layerProfile->getSRS()->isEquivalentTo( ext.getSRS())) { ext = layerProfile->clampAndTransformExtent( ext ); } hasDataInExtent = ext.isValid() && tileSource->hasDataInExtent( ext ); } if (hasDataInExtent) { while( !geoImage.valid() && imageKey.valid() && _layer->isKeyValid(imageKey) ) { if ( useMercatorFastPath ) { bool mercFallbackData = false; geoImage = _layer->createImageInNativeProfile( imageKey, 0L, autoFallback, mercFallbackData ); if ( geoImage.valid() && mercFallbackData ) { isFallbackData = true; } } else { geoImage = _layer->createImage( imageKey, 0L, autoFallback ); } if ( !geoImage.valid() ) { imageKey = imageKey.createParentKey(); isFallbackData = true; } } } GeoLocator* locator = 0L; if ( !geoImage.valid() ) { // no image found, so make an empty one (one pixel alpha). geoImage = GeoImage( ImageUtils::createEmptyImage(), _key.getExtent() ); locator = GeoLocator::createForKey( _key, *_mapInfo ); isFallbackData = true; } else { if ( useMercatorFastPath ) locator = new MercatorLocator(geoImage.getExtent()); else locator = GeoLocator::createForExtent(geoImage.getExtent(), *_mapInfo); } bool isStreaming = _opt->loadingPolicy()->mode() == LoadingPolicy::MODE_PREEMPTIVE || _opt->loadingPolicy()->mode() == LoadingPolicy::MODE_SEQUENTIAL; if (geoImage.getImage() && isStreaming) { // protected against multi threaded access. This is a requirement in sequential/preemptive mode, // for example. This used to be in TextureCompositorTexArray::prepareImage. // TODO: review whether this affects performance. geoImage.getImage()->setDataVariance( osg::Object::DYNAMIC ); } // add the color layer to the repo. _repo->add( CustomColorLayer( _layer, geoImage.getImage(), locator, _key.getLevelOfDetail(), _key, isFallbackData ) ); }
osg::Node* GeodeticGraticule::buildTile( const TileKey& key, Map* map ) const { if ( _options->levels().size() <= key.getLevelOfDetail() ) { OE_WARN << LC << "Tried to create cell at non-existant level " << key.getLevelOfDetail() << std::endl; return 0L; } const GeodeticGraticuleOptions::Level& level = _options->levels()[key.getLevelOfDetail()]; //_levels[key.getLevelOfDetail()]; // the "-2" here is because normal tile paging gives you one subdivision already, // so we only need to account for > 1 subdivision factor. unsigned cellsPerTile = level._subdivisionFactor <= 2u ? 1u : 1u << (level._subdivisionFactor-2u); unsigned cellsPerTileX = std::max(1u, cellsPerTile); unsigned cellsPerTileY = std::max(1u, cellsPerTile); GeoExtent tileExtent = key.getExtent(); FeatureList latLines; FeatureList lonLines; static LatLongFormatter s_llf(LatLongFormatter::FORMAT_DECIMAL_DEGREES); double cellWidth = tileExtent.width() / cellsPerTileX; double cellHeight = tileExtent.height() / cellsPerTileY; const Style& lineStyle = level._lineStyle.isSet() ? *level._lineStyle : *_options->lineStyle(); const Style& textStyle = level._textStyle.isSet() ? *level._textStyle : *_options->textStyle(); bool hasText = textStyle.get<TextSymbol>() != 0L; osg::ref_ptr<osg::Group> labels; if ( hasText ) { labels = new osg::Group(); //TODO: This is a bug, if you don't turn on decluttering the text labels are giant. Need to determine what is wrong with LabelNodes without decluttering. Decluttering::setEnabled( labels->getOrCreateStateSet(), true ); } // spatial ref for features: const SpatialReference* geoSRS = tileExtent.getSRS()->getGeographicSRS(); // longitude lines for( unsigned cx = 0; cx < cellsPerTileX; ++cx ) { double clon = tileExtent.xMin() + cellWidth * (double)cx; LineString* lon = new LineString(2); lon->push_back( osg::Vec3d(clon, tileExtent.yMin(), 0) ); lon->push_back( osg::Vec3d(clon, tileExtent.yMax(), 0) ); lonLines.push_back( new Feature(lon, geoSRS) ); if ( hasText ) { for( unsigned cy = 0; cy < cellsPerTileY; ++cy ) { double clat = tileExtent.yMin() + (0.5*cellHeight) + cellHeight*(double)cy; LabelNode* label = new LabelNode( _mapNode.get(), GeoPoint(geoSRS, clon, clat), s_llf.format(clon), textStyle ); labels->addChild( label ); } } } // latitude lines for( unsigned cy = 0; cy < cellsPerTileY; ++cy ) { double clat = tileExtent.yMin() + cellHeight * (double)cy; if ( clat == key.getProfile()->getExtent().yMin() ) continue; LineString* lat = new LineString(2); lat->push_back( osg::Vec3d(tileExtent.xMin(), clat, 0) ); lat->push_back( osg::Vec3d(tileExtent.xMax(), clat, 0) ); latLines.push_back( new Feature(lat, geoSRS) ); if ( hasText ) { for( unsigned cx = 0; cx < cellsPerTileX; ++cx ) { double clon = tileExtent.xMin() + (0.5*cellWidth) + cellWidth*(double)cy; LabelNode* label = new LabelNode( _mapNode.get(), GeoPoint(geoSRS, clon, clat), s_llf.format(clat), textStyle ); labels->addChild( label ); } } } osg::Group* group = new osg::Group(); GeometryCompiler compiler; osg::ref_ptr<Session> session = new Session( map ); FilterContext context( session.get(), _featureProfile.get(), tileExtent ); // make sure we get sufficient tessellation: compiler.options().maxGranularity() = std::min(cellWidth, cellHeight) / 16.0; compiler.options().geoInterp() = GEOINTERP_GREAT_CIRCLE; osg::Node* lonNode = compiler.compile(lonLines, lineStyle, context); if ( lonNode ) group->addChild( lonNode ); compiler.options().geoInterp() = GEOINTERP_RHUMB_LINE; osg::Node* latNode = compiler.compile(latLines, lineStyle, context); if ( latNode ) group->addChild( latNode ); // add the labels. if ( labels.valid() ) group->addChild( labels.get() ); // get the geocentric tile center: osg::Vec3d tileCenter; tileExtent.getCentroid( tileCenter.x(), tileCenter.y() ); const SpatialReference* ecefSRS = tileExtent.getSRS()->getECEF(); osg::Vec3d centerECEF; tileExtent.getSRS()->transform( tileCenter, ecefSRS, centerECEF ); //tileExtent.getSRS()->transformToECEF( tileCenter, centerECEF ); osg::NodeCallback* ccc = 0L; // set up cluster culling. if ( tileExtent.getSRS()->isGeographic() && tileExtent.width() < 90.0 && tileExtent.height() < 90.0 ) { ccc = ClusterCullingFactory::create( group, centerECEF ); } // add a paging node for higher LODs: if ( key.getLevelOfDetail() + 1 < _options->levels().size() ) { const GeodeticGraticuleOptions::Level& nextLevel = _options->levels()[key.getLevelOfDetail()+1]; osg::BoundingSphere bs = group->getBound(); std::string uri = Stringify() << key.str() << "_" << getID() << "." << GRID_MARKER << "." << GRATICULE_EXTENSION; osg::PagedLOD* plod = new osg::PagedLOD(); plod->setCenter( bs.center() ); plod->addChild( group, std::max(level._minRange,nextLevel._maxRange), FLT_MAX ); plod->setFileName( 1, uri ); plod->setRange( 1, 0, nextLevel._maxRange ); group = plod; } // or, if this is the deepest level and there's a minRange set, we need an LOD: else if ( level._minRange > 0.0f ) { osg::LOD* lod = new osg::LOD(); lod->addChild( group, level._minRange, FLT_MAX ); group = lod; } if ( ccc ) { osg::Group* cccGroup = new osg::Group(); cccGroup->addCullCallback( ccc ); cccGroup->addChild( group ); group = cccGroup; } return group; }
void TFSPackager::package( FeatureSource* features, const std::string& destination, const std::string& layername, const std::string& description ) { if (!_destSRSString.empty()) { _srs = SpatialReference::create( _destSRSString ); } //Get the destination SRS from the feature source if it's not already set if (!_srs.valid()) { _srs = features->getFeatureProfile()->getSRS(); } //Get the extent of the dataset, or use the custom extent value GeoExtent srsExtent = _customExtent; if (!srsExtent.isValid()) srsExtent = features->getFeatureProfile()->getExtent(); //Transform to lat/lon extents GeoExtent extent = srsExtent.transform( _srs.get() ); osg::ref_ptr< const osgEarth::Profile > profile = osgEarth::Profile::create(extent.getSRS(), extent.xMin(), extent.yMin(), extent.xMax(), extent.yMax(), 1, 1); TileKey rootKey = TileKey(0, 0, 0, profile ); osg::ref_ptr< FeatureTile > root = new FeatureTile( rootKey ); //Loop through all the features and try to insert them into the quadtree osg::ref_ptr< FeatureCursor > cursor = features->createFeatureCursor( _query ); int added = 0; int failed = 0; int skipped = 0; int highestLevel = 0; while (cursor.valid() && cursor->hasMore()) { osg::ref_ptr< Feature > feature = cursor->nextFeature(); //Reproject the feature to the dest SRS if it's not already if (!feature->getSRS()->isEquivalentTo( _srs ) ) { feature->transform( _srs ); } if (feature->getGeometry() && feature->getGeometry()->getBounds().valid() && feature->getGeometry()->isValid()) { AddFeatureVisitor v(feature.get(), _maxFeatures, _firstLevel, _maxLevel, _method); root->accept( &v ); if (!v._added) { OE_NOTICE << "Failed to add feature " << feature->getFID() << std::endl; failed++; } else { if (highestLevel < v._levelAdded) { highestLevel = v._levelAdded; } added++; OE_DEBUG << "Added " << added << std::endl; } } else { OE_NOTICE << "Skipping feature " << feature->getFID() << " with null or invalid geometry" << std::endl; skipped++; } } OE_NOTICE << "Added=" << added << " Skipped=" << skipped << " Failed=" << failed << std::endl; #if 1 // Print the width of tiles at each level for (int i = 0; i <= highestLevel; ++i) { TileKey tileKey(i, 0, 0, profile); GeoExtent tileExtent = tileKey.getExtent(); OE_NOTICE << "Level " << i << " tile size: " << tileExtent.width() << std::endl; } #endif WriteFeaturesVisitor write(features, destination, _method, _srs); root->accept( &write ); //Write out the meta doc TFSLayer layer; layer.setTitle( layername ); layer.setAbstract( description ); layer.setFirstLevel( _firstLevel ); layer.setMaxLevel( highestLevel ); layer.setExtent( profile->getExtent() ); layer.setSRS( _srs.get() ); TFSReaderWriter::write( layer, osgDB::concatPaths( destination, "tfs.xml")); }
// Calculates a sub-extent of a larger extent, given the number of children and // the child number. This currently assumes the subdivision ordering used by // VirtualPlanetBuilder. GeoExtent TerrainUtils::getSubExtent(const GeoExtent& extent, int num_children, int child_no) { GeoPoint centroid = extent.getCentroid(); GeoExtent sub_extent; switch( num_children ) { case 0: case 1: sub_extent = extent; break; case 2: if ( child_no == 0 ) { sub_extent = GeoExtent( extent.getXMin(), extent.getYMin(), centroid.x(), extent.getYMax(), extent.getSRS() ); } else { sub_extent = GeoExtent( centroid.x(), extent.getYMin(), extent.getXMax(), extent.getYMax(), extent.getSRS() ); } break; case 4: if ( child_no == 2 ) { sub_extent = GeoExtent( extent.getXMin(), centroid.y(), centroid.x(), extent.getYMax(), extent.getSRS() ); } else if ( child_no == 3 ) { sub_extent = GeoExtent( centroid.x(), centroid.y(), extent.getXMax(), extent.getYMax(), extent.getSRS() ); } else if ( child_no == 0 ) { sub_extent = GeoExtent( extent.getXMin(), extent.getYMin(), centroid.x(), centroid.y(), extent.getSRS() ); } else if ( child_no == 1 ) { sub_extent = GeoExtent( centroid.x(), extent.getYMin(), extent.getXMax(), centroid.y(), extent.getSRS() ); } } return sub_extent; }
osg::Node* SingleKeyNodeFactory::createTile(TileModel* model, bool setupChildrenIfNecessary, ProgressCallback* progress) { #ifdef EXPERIMENTAL_TILE_NODE_CACHE osg::ref_ptr<TileNode> tileNode; TileNodeCache::Record rec; cache.get(model->_tileKey, rec); if ( rec.valid() ) { tileNode = rec.value().get(); } else { tileNode = _modelCompiler->compile( model, _frame ); cache.insert(model->_tileKey, tileNode); } #else // compile the model into a node: TileNode* tileNode = _modelCompiler->compile(model, _frame, progress); tileNode->setEngineUID( _engineUID ); #endif // see if this tile might have children. bool prepareForChildren = setupChildrenIfNecessary && model->_tileKey.getLOD() < *_options.maxLOD(); osg::Node* result = 0L; if ( prepareForChildren ) { osg::BoundingSphere bs = tileNode->getBound(); TilePagedLOD* plod = new TilePagedLOD( _engineUID, _liveTiles, _deadTiles ); plod->setCenter ( bs.center() ); plod->addChild ( tileNode ); plod->setFileName( 1, Stringify() << tileNode->getKey().str() << "." << _engineUID << ".osgearth_engine_mp_tile" ); plod->setDebug ( _debug ); if ( _options.rangeMode().value() == osg::LOD::DISTANCE_FROM_EYE_POINT ) { //Compute the min range based on the 2D size of the tile GeoExtent extent = model->_tileKey.getExtent(); double radius = 0.0; #if 0 // Test code to use the equitorial radius so that all of the tiles at the same level // have the same range. This will make the poles page in more appropriately. if (_frame.getMapInfo().isGeocentric()) { GeoExtent equatorialExtent( extent.getSRS(), extent.west(), -extent.height()/2.0, extent.east(), extent.height()/2.0 ); radius = equatorialExtent.getBoundingGeoCircle().getRadius(); } else #endif { GeoPoint lowerLeft(extent.getSRS(), extent.xMin(), extent.yMin(), 0.0, ALTMODE_ABSOLUTE); GeoPoint upperRight(extent.getSRS(), extent.xMax(), extent.yMax(), 0.0, ALTMODE_ABSOLUTE); osg::Vec3d ll, ur; lowerLeft.toWorld( ll ); upperRight.toWorld( ur ); radius = (ur - ll).length() / 2.0; } float minRange = (float)(radius * _options.minTileRangeFactor().value()); plod->setRange( 0, minRange, FLT_MAX ); plod->setRange( 1, 0, minRange ); plod->setRangeMode( osg::LOD::DISTANCE_FROM_EYE_POINT ); } else { // the *2 is because we page in 4-tile sets, not individual tiles. float size = 2.0f * _options.tilePixelSize().value(); plod->setRange( 0, 0.0f, size ); plod->setRange( 1, size, FLT_MAX ); plod->setRangeMode( osg::LOD::PIXEL_SIZE_ON_SCREEN ); } // Install a tile-aligned bounding box in the pager node itself so we can do // visibility testing before paging in subtiles. plod->setChildBoundingBoxAndMatrix( 1, tileNode->getTerrainBoundingBox(), tileNode->getMatrix() ); // DBPager will set a priority based on the ratio range/maxRange. // This will offset that number with a full LOD #, giving LOD precedence. // Experimental. //plod->setPriorityScale( 1, model->_tileKey.getLOD()+1 ); #if USE_FILELOCATIONCALLBACK osgDB::Options* options = plod->getOrCreateDBOptions(); options->setFileLocationCallback( new FileLocationCallback() ); #endif result = plod; // this one rejects back-facing tiles: if ( _frame.getMapInfo().isGeocentric() && _options.clusterCulling() == true ) { #if 1 osg::HeightField* hf = model->_elevationData.getHeightField(); result->addCullCallback( HeightFieldUtils::createClusterCullingCallback( hf, tileNode->getKey().getProfile()->getSRS()->getEllipsoid(), *_options.verticalScale() ) ); #else // This works, but isn't quite as tight at the cluster culler. // Re-evaluate down the road. result->addCullCallback( new HorizonTileCuller( _frame.getMapInfo().getSRS(), tileNode->getTerrainBoundingBox(), tileNode->getMatrix(), tileNode->getKey() ) ); #endif } } else { result = tileNode; } return result; }
//override bool renderFeaturesForStyle( const Style& style, const FeatureList& features, osg::Referenced* buildData, const GeoExtent& imageExtent, osg::Image* image ) { // A processing context to use with the filters: FilterContext context; context.setProfile( getFeatureSource()->getFeatureProfile() ); const LineSymbol* masterLine = style.getSymbol<LineSymbol>(); const PolygonSymbol* masterPoly = style.getSymbol<PolygonSymbol>(); // sort into bins, making a copy for lines that require buffering. FeatureList polygons; FeatureList lines; for(FeatureList::const_iterator f = features.begin(); f != features.end(); ++f) { if ( f->get()->getGeometry() ) { if ( masterPoly || f->get()->style()->has<PolygonSymbol>() ) { polygons.push_back( f->get() ); } if ( masterLine || f->get()->style()->has<LineSymbol>() ) { Feature* newFeature = new Feature( *f->get() ); if ( !newFeature->getGeometry()->isLinear() ) { newFeature->setGeometry( newFeature->getGeometry()->cloneAs(Geometry::TYPE_RING) ); } lines.push_back( newFeature ); } } } // initialize: RenderFrame frame; frame.xmin = imageExtent.xMin(); frame.ymin = imageExtent.yMin(); frame.xf = (double)image->s() / imageExtent.width(); frame.yf = (double)image->t() / imageExtent.height(); if ( lines.size() > 0 ) { // We are buffering in the features native extent, so we need to use the // transformed extent to get the proper "resolution" for the image const SpatialReference* featureSRS = context.profile()->getSRS(); GeoExtent transformedExtent = imageExtent.transform(featureSRS); double trans_xf = (double)image->s() / transformedExtent.width(); double trans_yf = (double)image->t() / transformedExtent.height(); // resolution of the image (pixel extents): double xres = 1.0/trans_xf; double yres = 1.0/trans_yf; // downsample the line data so that it is no higher resolution than to image to which // we intend to rasterize it. If you don't do this, you run the risk of the buffer // operation taking forever on very high-res input data. if ( _options.optimizeLineSampling() == true ) { ResampleFilter resample; resample.minLength() = osg::minimum( xres, yres ); context = resample.push( lines, context ); } // now run the buffer operation on all lines: BufferFilter buffer; double lineWidth = 1.0; if ( masterLine ) { buffer.capStyle() = masterLine->stroke()->lineCap().value(); if ( masterLine->stroke()->width().isSet() ) { lineWidth = masterLine->stroke()->width().value(); GeoExtent imageExtentInFeatureSRS = imageExtent.transform(featureSRS); double pixelWidth = imageExtentInFeatureSRS.width() / (double)image->s(); // if the width units are specified, process them: if (masterLine->stroke()->widthUnits().isSet() && masterLine->stroke()->widthUnits().get() != Units::PIXELS) { const Units& featureUnits = featureSRS->getUnits(); const Units& strokeUnits = masterLine->stroke()->widthUnits().value(); // if the units are different than those of the feature data, we need to // do a units conversion. if ( featureUnits != strokeUnits ) { if ( Units::canConvert(strokeUnits, featureUnits) ) { // linear to linear, no problem lineWidth = strokeUnits.convertTo( featureUnits, lineWidth ); } else if ( strokeUnits.isLinear() && featureUnits.isAngular() ) { // linear to angular? approximate degrees per meter at the // latitude of the tile's centroid. lineWidth = masterLine->stroke()->widthUnits()->convertTo(Units::METERS, lineWidth); double circ = featureSRS->getEllipsoid()->getRadiusEquator() * 2.0 * osg::PI; double x, y; context.profile()->getExtent().getCentroid(x, y); double radians = (lineWidth/circ) * cos(osg::DegreesToRadians(y)); lineWidth = osg::RadiansToDegrees(radians); } } // enfore a minimum width of one pixel. float minPixels = masterLine->stroke()->minPixels().getOrUse( 1.0f ); lineWidth = osg::clampAbove(lineWidth, pixelWidth*minPixels); } else // pixels { lineWidth *= pixelWidth; } } } buffer.distance() = lineWidth * 0.5; // since the distance is for one side buffer.push( lines, context ); } // Transform the features into the map's SRS: TransformFilter xform( imageExtent.getSRS() ); xform.setLocalizeCoordinates( false ); FilterContext polysContext = xform.push( polygons, context ); FilterContext linesContext = xform.push( lines, context ); // set up the AGG renderer: agg::rendering_buffer rbuf( image->data(), image->s(), image->t(), image->s()*4 ); // Create the renderer and the rasterizer agg::renderer<agg::span_abgr32> ren(rbuf); agg::rasterizer ras; // Setup the rasterizer ras.gamma(1.3); ras.filling_rule(agg::fill_even_odd); // construct an extent for cropping the geometry to our tile. // extend just outside the actual extents so we don't get edge artifacts: GeoExtent cropExtent = GeoExtent(imageExtent); cropExtent.scale(1.1, 1.1); osg::ref_ptr<Symbology::Polygon> cropPoly = new Symbology::Polygon( 4 ); cropPoly->push_back( osg::Vec3d( cropExtent.xMin(), cropExtent.yMin(), 0 )); cropPoly->push_back( osg::Vec3d( cropExtent.xMax(), cropExtent.yMin(), 0 )); cropPoly->push_back( osg::Vec3d( cropExtent.xMax(), cropExtent.yMax(), 0 )); cropPoly->push_back( osg::Vec3d( cropExtent.xMin(), cropExtent.yMax(), 0 )); // render the polygons for(FeatureList::iterator i = polygons.begin(); i != polygons.end(); i++) { Feature* feature = i->get(); Geometry* geometry = feature->getGeometry(); osg::ref_ptr<Geometry> croppedGeometry; if ( geometry->crop( cropPoly.get(), croppedGeometry ) ) { const PolygonSymbol* poly = feature->style().isSet() && feature->style()->has<PolygonSymbol>() ? feature->style()->get<PolygonSymbol>() : masterPoly; const osg::Vec4 color = poly ? static_cast<osg::Vec4>(poly->fill()->color()) : osg::Vec4(1,1,1,1); rasterize(croppedGeometry.get(), color, frame, ras, ren); } } // render the lines for(FeatureList::iterator i = lines.begin(); i != lines.end(); i++) { Feature* feature = i->get(); Geometry* geometry = feature->getGeometry(); osg::ref_ptr<Geometry> croppedGeometry; if ( geometry->crop( cropPoly.get(), croppedGeometry ) ) { const LineSymbol* line = feature->style().isSet() && feature->style()->has<LineSymbol>() ? feature->style()->get<LineSymbol>() : masterLine; const osg::Vec4 color = line ? static_cast<osg::Vec4>(line->stroke()->color()) : osg::Vec4(1,1,1,1); rasterize(croppedGeometry.get(), color, frame, ras, ren); } } return true; }