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;
}
