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;
}
osg::Group*
FeatureModelGraph::build( const FeatureLevel& level, const GeoExtent& extent, const TileKey* key )
{
// set up for feature indexing if appropriate:
osg::ref_ptr<osg::Group> group;
FeatureSourceIndexNode* index = 0L;
if ( _session->getFeatureSource() && (_options.featureIndexing() == true) )
{
index = new FeatureSourceIndexNode( _session->getFeatureSource() );
group = index;
}
else
{
group = new osg::Group();
}
// form the baseline query, which does a spatial query based on the working extent.
Query query;
if ( extent.isValid() )
query.bounds() = extent.bounds();
// add a tile key to the query if there is one, to support TFS-style queries
if ( key )
query.tileKey() = *key;
// now, go through any level-based selectors.
const StyleSelectorVector& levelSelectors = level.selectors();
// if there are none, just build once with the default style and query.
if ( levelSelectors.size() == 0 )
{
// attempt to glean the style from the feature source name:
const Style style = *_session->styles()->getStyle(
*_session->getFeatureSource()->getFeatureSourceOptions().name() );
osg::Node* node = build( style, query, extent, index );
if ( node )
group->addChild( node );
}
else
{
for( StyleSelectorVector::const_iterator i = levelSelectors.begin(); i != levelSelectors.end(); ++i )
{
const StyleSelector& selector = *i;
// fetch the selector's style:
const Style* selectorStyle = _session->styles()->getStyle( selector.getSelectedStyleName() );
// combine the selector's query, if it has one:
Query selectorQuery =
selector.query().isSet() ? query.combineWith( *selector.query() ) : query;
osg::Node* node = build( *selectorStyle, selectorQuery, extent, index );
if ( node )
group->addChild( node );
}
}
if ( group->getNumChildren() > 0 )
{
// account for a min-range here.
if ( level.minRange() > 0.0f )
{
osg::LOD* lod = new osg::LOD();
lod->addChild( group.get(), level.minRange(), FLT_MAX );
group = lod;
}
if ( _session->getMapInfo().isGeocentric() && _options.clusterCulling() == true )
{
const FeatureProfile* featureProfile = _session->getFeatureSource()->getFeatureProfile();
const GeoExtent& ccExtent = extent.isValid() ? extent : featureProfile->getExtent();
if ( ccExtent.isValid() )
{
// if the extent is more than 90 degrees, bail
GeoExtent geodeticExtent = ccExtent.transform( ccExtent.getSRS()->getGeographicSRS() );
if ( geodeticExtent.width() < 90.0 && geodeticExtent.height() < 90.0 )
{
#if 1
// get the geocentric tile center:
osg::Vec3d tileCenter;
ccExtent.getCentroid( tileCenter.x(), tileCenter.y() );
osg::Vec3d centerECEF;
ccExtent.getSRS()->transformToECEF( tileCenter, centerECEF );
osg::NodeCallback* ccc = ClusterCullerFactory::create( group.get(), centerECEF );
if ( ccc )
group->addCullCallback( ccc );
#endif
}
}
}
// if indexing is enabled, build the index now.
if ( index )
index->reindex();
return group.release();
}
else
{
return 0L;
}
}
//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( _engine->getUID(), _liveTiles, _deadTiles );
plod->setCenter ( bs.center() );
plod->addChild ( tileNode );
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;
#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());
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;
}
return result;
}
//override
bool renderFeaturesForStyle(
Session* session,
const Style& style,
const FeatureList& features,
osg::Referenced* buildData,
const GeoExtent& imageExtent,
osg::Image* image )
{
OE_DEBUG << LC << "Rendering " << features.size() << " features for " << imageExtent.toString() << "\n";
// A processing context to use with the filters:
FilterContext context( session );
context.setProfile( getFeatureSource()->getFeatureProfile() );
const LineSymbol* masterLine = style.getSymbol<LineSymbol>();
const PolygonSymbol* masterPoly = style.getSymbol<PolygonSymbol>();
const CoverageSymbol* masterCov = style.getSymbol<CoverageSymbol>();
// 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() )
{
bool hasPoly = false;
bool hasLine = false;
if ( masterPoly || f->get()->style()->has<PolygonSymbol>() )
{
polygons.push_back( f->get() );
hasPoly = true;
}
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 );
hasLine = true;
}
// if there are no geometry symbols but there is a coverage symbol, default to polygons.
if ( !hasLine && !hasPoly )
{
if ( masterCov || f->get()->style()->has<CoverageSymbol>() )
{
polygons.push_back( f->get() );
}
}
}
}
// 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.
double lineWidthM = masterLine->stroke()->widthUnits()->convertTo(Units::METERS, lineWidth);
double mPerDegAtEquatorInv = 360.0/(featureSRS->getEllipsoid()->getRadiusEquator() * 2.0 * osg::PI);
double lon, lat;
imageExtent.getCentroid(lon, lat);
lineWidth = lineWidthM * mPerDegAtEquatorInv * cos(osg::DegreesToRadians(lat));
}
}
// 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::rasterizer ras;
// Setup the rasterizer
if ( _options.coverage() == true )
ras.gamma(1.0);
else
ras.gamma(_options.gamma().get());
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 ));
// If there's a coverage symbol, make a copy of the expressions so we can evaluate them
optional<NumericExpression> covValue;
const CoverageSymbol* covsym = style.get<CoverageSymbol>();
if (covsym && covsym->valueExpression().isSet())
covValue = covsym->valueExpression().get();
// 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;
if ( _options.coverage() == true && covValue.isSet() )
{
float value = (float)feature->eval(covValue.mutable_value(), &context);
rasterizeCoverage(croppedGeometry.get(), value, frame, ras, rbuf);
}
else
{
osg::Vec4f color = poly->fill()->color();
rasterize(croppedGeometry.get(), color, frame, ras, rbuf);
}
}
}
// 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;
if ( _options.coverage() == true && covValue.isSet() )
{
float value = (float)feature->eval(covValue.mutable_value(), &context);
rasterizeCoverage(croppedGeometry.get(), value, frame, ras, rbuf);
}
else
{ osg::Vec4f color = line ? static_cast<osg::Vec4>(line->stroke()->color()) : osg::Vec4(1,1,1,1);
rasterize(croppedGeometry.get(), color, frame, ras, rbuf);
}
}
}
return true;
}
/**
* Builds geometry for feature data at a particular level, and constrained by an extent.
* The extent is either (a) expressed in "extent" literally, as is the case in a non-tiled
* data source, or (b) expressed implicitly by a TileKey, which is the case for a tiled
* data source.
*/
osg::Group*
FeatureModelGraph::buildLevel( const FeatureLevel& level, const GeoExtent& extent, const TileKey* key )
{
// set up for feature indexing if appropriate:
osg::ref_ptr<osg::Group> group;
FeatureSourceIndexNode* index = 0L;
if ( _session->getFeatureSource() && (_options.featureIndexing() == true) )
{
index = new FeatureSourceIndexNode( _session->getFeatureSource(), _options.storingAttributesOnFeatureIndexing() == true );
group = index;
}
else
{
group = new osg::Group();
}
// form the baseline query, which does a spatial query based on the working extent.
Query query;
if ( extent.isValid() )
query.bounds() = extent.bounds();
// add a tile key to the query if there is one, to support TFS-style queries
if ( key )
query.tileKey() = *key;
// does the level have a style name set?
if ( level.styleName().isSet() )
{
osg::Node* node = 0L;
const Style* style = _session->styles()->getStyle( *level.styleName(), false );
if ( style )
{
// found a specific style to use.
node = createStyleGroup( *style, query, index );
if ( node )
group->addChild( node );
}
else
{
const StyleSelector* selector = _session->styles()->getSelector( *level.styleName() );
if ( selector )
{
buildStyleGroups( selector, query, index, group.get() );
}
}
}
else
{
Style defaultStyle;
if ( _session->styles()->selectors().size() == 0 )
{
// attempt to glean the style from the feature source name:
defaultStyle = *_session->styles()->getStyle(
*_session->getFeatureSource()->getFeatureSourceOptions().name() );
}
osg::Node* node = build( defaultStyle, query, extent, index );
if ( node )
group->addChild( node );
}
if ( group->getNumChildren() > 0 )
{
// account for a min-range here. Do not address the max-range here; that happens
// above when generating paged LOD nodes, etc.
float minRange = level.minRange();
if ( minRange > 0.0f )
{
// minRange can't be less than the tile geometry's radius.
minRange = std::max(minRange, (float)group->getBound().radius());
osg::LOD* lod = new osg::LOD();
lod->addChild( group.get(), minRange, FLT_MAX );
group = lod;
}
if ( _session->getMapInfo().isGeocentric() && _options.clusterCulling() == true )
{
const FeatureProfile* featureProfile = _session->getFeatureSource()->getFeatureProfile();
const GeoExtent& ccExtent = extent.isValid() ? extent : featureProfile->getExtent();
if ( ccExtent.isValid() )
{
// if the extent is more than 90 degrees, bail
GeoExtent geodeticExtent = ccExtent.transform( ccExtent.getSRS()->getGeographicSRS() );
if ( geodeticExtent.width() < 90.0 && geodeticExtent.height() < 90.0 )
{
// get the geocentric tile center:
osg::Vec3d tileCenter;
ccExtent.getCentroid( tileCenter.x(), tileCenter.y() );
osg::Vec3d centerECEF;
ccExtent.getSRS()->transformToECEF( tileCenter, centerECEF );
osg::NodeCallback* ccc = ClusterCullingFactory::create2( group.get(), centerECEF );
if ( ccc )
group->addCullCallback( ccc );
}
}
}
// if indexing is enabled, build the index now.
if ( index )
index->reindex();
return group.release();
}
else
{
return 0L;
}
}
void
Profile::addIntersectingTiles(const GeoExtent& key_ext, 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;
}
#if 0 // works for meracator; does NOT work for cube
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);
int tileMinX = quantize( ((key_ext.xMin() - _extent.xMin()) / destTileWidth), eps );
int tileMaxX = (int)((key_ext.xMax() - _extent.xMin()) / destTileWidth);
int tileMinY = quantize( ((_extent.yMax() - key_ext.yMax()) / destTileHeight), eps );
int tileMaxY = (int) ((_extent.yMax() - key_ext.yMin()) / destTileHeight);
#else
double keyWidth = key_ext.width();
double keyHeight = key_ext.height();
// bail out if the key has a null extent. This might happen is the original key represents an
// area in one profile that is out of bounds in this profile.
if ( keyWidth <= 0.0 && keyHeight <= 0.0 )
return;
double keySpan = std::min( keyWidth, keyHeight );
double keyArea = keyWidth * keyHeight;
double keyAvg = 0.5*(keyWidth+keyHeight);
int destLOD = 1;
double destTileWidth, destTileHeight;
int currLOD = 0;
destLOD = currLOD;
getTileDimensions(destLOD, destTileWidth, destTileHeight);
while( true )
{
currLOD++;
double w, h;
getTileDimensions(currLOD, w, h);
if ( w < keyAvg || h < keyAvg ) break;
destLOD = currLOD;
destTileWidth = w;
destTileHeight = h;
}
//OE_DEBUG << std::fixed << " Source Tile: " << key.getLevelOfDetail() << " (" << keyWidth << ", " << keyHeight << ")" << std::endl;
//OE_DEBUG << std::fixed << " Dest Size: " << destLOD << " (" << destTileWidth << ", " << destTileHeight << ")" << std::endl;
int tileMinX = (int)((key_ext.xMin() - _extent.xMin()) / destTileWidth);
int tileMaxX = (int)((key_ext.xMax() - _extent.xMin()) / destTileWidth);
int tileMinY = (int)((_extent.yMax() - key_ext.yMax()) / destTileHeight);
int tileMaxY = (int)((_extent.yMax() - key_ext.yMin()) / destTileHeight);
#endif
unsigned int numWide, numHigh;
getNumTiles(destLOD, 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(destLOD, i, j, this) );
}
}
//OE_INFO << " Found " << out_intersectingKeys.size() << " keys " << std::endl;
}
