FilterContext
TransformFilter::push( FeatureList& input, FilterContext& incx )
{
_bbox = osg::BoundingBoxd();
// first transform all the points into the output SRS, collecting a bounding box as we go:
bool ok = true;
for( FeatureList::iterator i = input.begin(); i != input.end(); i++ )
if ( !push( i->get(), incx ) )
ok = false;
FilterContext outcx( incx );
outcx.isGeocentric() = _makeGeocentric;
if ( _outputSRS.valid() )
{
if ( incx.extent()->isValid() )
outcx.profile() = new FeatureProfile( incx.extent()->transform( _outputSRS.get() ) );
else
outcx.profile() = new FeatureProfile( incx.profile()->getExtent().transform( _outputSRS.get() ) );
}
// set the reference frame to shift data to the centroid. This will
// prevent floating point precision errors in the openGL pipeline for
// properly gridded data.
if ( _bbox.valid() && _localize )
{
// create a suitable reference frame:
osg::Matrixd localizer;
if ( _makeGeocentric )
{
localizer = createGeocentricInvRefFrame( _bbox.center(), _outputSRS.get() );
localizer.invert( localizer );
}
else
{
localizer = osg::Matrixd::translate( -_bbox.center() );
}
// localize the geometry relative to the reference frame.
for( FeatureList::iterator i = input.begin(); i != input.end(); i++ )
{
localizeGeometry( i->get(), localizer );
}
outcx.setReferenceFrame( localizer );
}
return outcx;
}
void
CollectionFilterState::push( const FeatureList& input )
{
for( FeatureList::const_iterator i = input.begin(); i != input.end(); i++ )
if ( i->get()->hasShapeData() )
features.push_back( i->get() );
}
FilterContext
ScaleFilter::push( FeatureList& input, FilterContext& cx )
{
for( FeatureList::iterator i = input.begin(); i != input.end(); ++i )
{
Feature* input = i->get();
if ( input && input->getGeometry() )
{
Bounds envelope = input->getGeometry()->getBounds();
// now scale and shift everything
GeometryIterator scale_iter( input->getGeometry() );
while( scale_iter.hasMore() )
{
Geometry* geom = scale_iter.next();
for( osg::Vec3dArray::iterator v = geom->begin(); v != geom->end(); v++ )
{
double xr = (v->x() - envelope.xMin()) / envelope.width();
v->x() += (xr - 0.5) * _scale;
double yr = (v->y() - envelope.yMin()) / envelope.height();
v->y() += (yr - 0.5) * _scale;
}
}
}
}
return cx;
}
FilterContext
ScriptFilter::push( FeatureList& input, FilterContext& context )
{
if ( !isSupported() )
{
OE_WARN << "ScriptFilter support not enabled" << std::endl;
return context;
}
if (!_engine.valid())
{
OE_WARN << "No scripting engine\n";
return context;
}
bool ok = true;
for( FeatureList::iterator i = input.begin(); i != input.end(); )
{
if ( push( i->get(), context ) )
{
++i;
}
else
{
i = input.erase(i);
}
}
return context;
}
// reads a chunk of features into a memory cache; do this for performance
// and to avoid needing the OGR Mutex every time
void
FeatureCursorOGR::readChunk()
{
if ( !_resultSetHandle )
return;
OGR_SCOPED_LOCK;
while( _queue.size() < _chunkSize && !_resultSetEndReached )
{
FeatureList filterList;
while( filterList.size() < _chunkSize && !_resultSetEndReached )
{
OGRFeatureH handle = OGR_L_GetNextFeature( _resultSetHandle );
if ( handle )
{
osg::ref_ptr<Feature> feature = OgrUtils::createFeature( handle, _profile.get() );
if (feature.valid() &&
!_source->isBlacklisted( feature->getFID() ) &&
validateGeometry( feature->getGeometry() ))
{
filterList.push_back( feature.release() );
}
OGR_F_Destroy( handle );
}
else
{
_resultSetEndReached = true;
}
}
// preprocess the features using the filter list:
if ( !_filters.empty() )
{
FilterContext cx;
cx.setProfile( _profile.get() );
if (_query.bounds().isSet())
{
cx.extent() = GeoExtent(_profile->getSRS(), _query.bounds().get());
}
else
{
cx.extent() = _profile->getExtent();
}
for( FeatureFilterList::const_iterator i = _filters.begin(); i != _filters.end(); ++i )
{
FeatureFilter* filter = i->get();
cx = filter->push( filterList, cx );
}
}
for(FeatureList::const_iterator i = filterList.begin(); i != filterList.end(); ++i)
{
_queue.push( i->get() );
}
}
}
void
ImageOverlay::init()
{
OpenThreads::ScopedLock< OpenThreads::Mutex > lock(_mutex);
if (_root->getNumChildren() > 0)
{
_root->removeChildren(0, _root->getNumChildren());
}
if ( !_clampCallback.valid() )
{
_clampCallback = new TerrainCallbackAdapter<ImageOverlay>(this);
}
if ( getMapNode() )
{
const SpatialReference* mapSRS = getMapNode()->getMapSRS();
// calculate a bounding polytope in world space (for mesh clamping):
osg::ref_ptr<Feature> f = new Feature( new Polygon(), mapSRS->getGeodeticSRS() );
Geometry* g = f->getGeometry();
g->push_back( osg::Vec3d(_lowerLeft.x(), _lowerLeft.y(), 0) );
g->push_back( osg::Vec3d(_lowerRight.x(), _lowerRight.y(), 0) );
g->push_back( osg::Vec3d(_upperRight.x(), _upperRight.y(), 0) );
g->push_back( osg::Vec3d(_upperLeft.x(), _upperLeft.y(), 0) );
f->getWorldBoundingPolytope( getMapNode()->getMapSRS(), _boundingPolytope );
FeatureList features;
if (!mapSRS->isGeographic())
{
f->splitAcrossDateLine(features);
}
else
{
features.push_back( f );
}
for (FeatureList::iterator itr = features.begin(); itr != features.end(); ++itr)
{
_root->addChild(createNode(itr->get(), features.size() > 1));
}
_dirty = false;
// Set the annotation up for auto-clamping. We always need to auto-clamp a draped image
// so that the mesh roughly conforms with the surface, otherwise the draping routine
// might clip it.
Style style;
style.getOrCreate<AltitudeSymbol>()->clamping() = AltitudeSymbol::CLAMP_RELATIVE_TO_TERRAIN;
applyStyle( style );
setLightingIfNotSet( false );
getMapNode()->getTerrain()->addTerrainCallback( _clampCallback.get() );
clamp( getMapNode()->getTerrain()->getGraph(), getMapNode()->getTerrain() );
}
}
void
AltitudeFilter::pushAndDontClamp( FeatureList& features, FilterContext& cx )
{
NumericExpression scaleExpr;
if ( _altitude.valid() && _altitude->verticalScale().isSet() )
scaleExpr = *_altitude->verticalScale();
NumericExpression offsetExpr;
if ( _altitude.valid() && _altitude->verticalOffset().isSet() )
offsetExpr = *_altitude->verticalOffset();
for( FeatureList::iterator i = features.begin(); i != features.end(); ++i )
{
Feature* feature = i->get();
// run a symbol script if present.
if ( _altitude.valid() && _altitude->script().isSet() )
{
StringExpression temp( _altitude->script().get() );
feature->eval( temp, &cx );
}
double minHAT = DBL_MAX;
double maxHAT = -DBL_MAX;
double scaleZ = 1.0;
if ( _altitude.valid() && _altitude->verticalScale().isSet() )
scaleZ = feature->eval( scaleExpr, &cx );
double offsetZ = 0.0;
if ( _altitude.valid() && _altitude->verticalOffset().isSet() )
offsetZ = feature->eval( offsetExpr, &cx );
GeometryIterator gi( feature->getGeometry() );
while( gi.hasMore() )
{
Geometry* geom = gi.next();
for( Geometry::iterator g = geom->begin(); g != geom->end(); ++g )
{
g->z() *= scaleZ;
g->z() += offsetZ;
if ( g->z() < minHAT )
minHAT = g->z();
if ( g->z() > maxHAT )
maxHAT = g->z();
}
}
if ( minHAT != DBL_MAX )
{
feature->set( "__min_hat", minHAT );
feature->set( "__max_hat", maxHAT );
}
}
}
virtual FilterContext push( FeatureList& input, FilterContext& context )
{
for (FeatureList::iterator itr = input.begin(); itr != input.end(); itr++)
{
//Change the value of the attribute
if (_key.isSet() && _value.isSet())
{
itr->get()->set(*_key, std::string(*_value));
}
}
return context;
}
FilterContext
ClampFilter::push( FeatureList& features, const FilterContext& cx )
{
const Session* session = cx.getSession();
if ( !session ) {
OE_WARN << LC << "No session - session is required for elevation clamping" << std::endl;
return cx;
}
// the map against which we'll be doing elevation clamping
MapFrame mapf = session->createMapFrame( Map::ELEVATION_LAYERS );
const SpatialReference* mapSRS = mapf.getProfile()->getSRS();
const SpatialReference* featureSRS = cx.profile()->getSRS();
bool isGeocentric = session->getMapInfo().isGeocentric();
// establish an elevation query interface based on the features' SRS.
ElevationQuery eq( mapf );
for( FeatureList::iterator i = features.begin(); i != features.end(); ++i )
{
Feature* feature = i->get();
GeometryIterator gi( feature->getGeometry() );
while( gi.hasMore() )
{
Geometry* geom = gi.next();
if ( isGeocentric )
{
// convert to map coords:
cx.toWorld( geom );
mapSRS->transformFromECEF( geom );
// populate the elevations:
eq.getElevations( geom, mapSRS );
// convert back to geocentric:
mapSRS->transformToECEF( geom );
cx.toLocal( geom );
}
else
{
// clamps the entire array to the highest available resolution.
eq.getElevations( geom, featureSRS );
}
}
}
return cx;
}
//clustering:
// troll the external model for geodes. for each geode, create a geode in the target
// model. then, for each geometry in that geode, replicate it once for each instance of
// the model in the feature batch and transform the actual verts to a local offset
// relative to the tile centroid. Finally, reassemble all the geodes and optimize.
// hopefully stateset sharing etc will work out. we may need to strip out LODs too.
bool
SubstituteModelFilter::cluster(const FeatureList& features,
const MarkerSymbol* symbol,
Session* session,
osg::Group* attachPoint,
FilterContext& cx )
{
MarkerToFeatures markerToFeatures;
MarkerFactory factory( session);
for (FeatureList::const_iterator i = features.begin(); i != features.end(); ++i)
{
Feature* f = i->get();
osg::ref_ptr< osg::Node > model = factory.getOrCreateNode( f, symbol );
//Try to find the existing entry
if (model.valid())
{
MarkerToFeatures::iterator itr = markerToFeatures.find( model.get() );
if (itr == markerToFeatures.end())
{
markerToFeatures[ model.get() ].push_back( f );
}
else
{
itr->second.push_back( f );
}
}
}
/*
OE_NOTICE << "Sorted models into " << markerToFeatures.size() << " buckets" << std::endl;
for (MarkerToFeatures::iterator i = markerToFeatures.begin(); i != markerToFeatures.end(); ++i)
{
OE_NOTICE << " Bucket has " << i->second.size() << " features" << std::endl;
}
*/
//For each model, cluster the features that use that model
for (MarkerToFeatures::iterator i = markerToFeatures.begin(); i != markerToFeatures.end(); ++i)
{
osg::Node* clone = dynamic_cast<osg::Node*>( i->first->clone( osg::CopyOp::DEEP_COPY_ALL ) );
// ..and apply the clustering to the copy.
ClusterVisitor cv( i->second, _modelMatrix, this, cx );
clone->accept( cv );
attachPoint->addChild( clone );
}
return true;
}
FeatureNode::FeatureNode(const FeatureList& features,
const Style& style,
const GeometryCompilerOptions& options,
StyleSheet* styleSheet):
AnnotationNode(),
_options ( options ),
_needsRebuild ( true ),
_styleSheet ( styleSheet ),
_clampDirty ( false ),
_index ( 0 )
{
_features.insert( _features.end(), features.begin(), features.end() );
setStyle( style );
}
FeatureNode::FeatureNode(MapNode* mapNode,
FeatureList& features,
const Style& style,
const GeometryCompilerOptions& options,
StyleSheet* styleSheet):
AnnotationNode(),
_options ( options ),
_needsRebuild ( true ),
_styleSheet ( styleSheet )
{
_features.insert( _features.end(), features.begin(), features.end() );
FeatureNode::setMapNode( mapNode );
setStyle( style );
}
FeatureNode::FeatureNode(MapNode* mapNode,
FeatureList& features,
const Style& style,
const GeometryCompilerOptions& options,
StyleSheet* styleSheet):
AnnotationNode( mapNode ),
_style ( style ),
_options ( options ),
_needsRebuild (true),
_clusterCulling(true),
_clusterCullingCallback(0),
_styleSheet( styleSheet )
{
_features.insert( _features.end(), features.begin(), features.end() );
build();
}
FilterContext
ResampleFilter::push( FeatureList& input, FilterContext& context )
{
if ( !isSupported() )
{
OE_WARN << "ResampleFilter support not enabled" << std::endl;
return context;
}
bool ok = true;
for( FeatureList::iterator i = input.begin(); i != input.end(); ++i )
if ( !push( i->get(), context ) )
ok = false;
return context;
}
FilterContext
BufferFilter::push( FeatureList& input, FilterContext& context )
{
if ( !isSupported() )
{
OE_WARN << "BufferFilter support not enabled - please compile osgEarth with GEOS" << std::endl;
return context;
}
//OE_NOTICE << "Buffer: input = " << input.size() << " features" << std::endl;
bool ok = true;
for( FeatureList::iterator i = input.begin(); i != input.end(); ++i )
if ( !push( i->get(), context ) )
ok = false;
return context;
}
FilterContext
CentroidFilter::push(FeatureList& features, FilterContext& context )
{
for( FeatureList::iterator i = features.begin(); i != features.end(); ++i )
{
Feature* f = i->get();
Geometry* geom = f->getGeometry();
if ( !geom )
continue;
PointSet* newGeom = new PointSet();
newGeom->push_back( geom->getBounds().center() );
f->setGeometry( newGeom );
}
return context;
}
FilterContext
ScatterFilter::push(FeatureList& features, FilterContext& context )
{
if ( !isSupported() ) {
OE_WARN << LC << "support for this filter is not enabled" << std::endl;
return context;
}
// seed the random number generator so the randomness is the same each time
_prng = Random( _randomSeed, Random::METHOD_FAST );
for( FeatureList::iterator i = features.begin(); i != features.end(); ++i )
{
Feature* f = i->get();
Geometry* geom = f->getGeometry();
if ( !geom )
continue;
const SpatialReference* geomSRS = context.profile()->getSRS();
osg::ref_ptr< PointSet > points = new PointSet();
if ( geom->getComponentType() == Geometry::TYPE_POLYGON )
{
polyScatter( geom, geomSRS, context, points.get() );
}
else if (
geom->getComponentType() == Geometry::TYPE_LINESTRING ||
geom->getComponentType() == Geometry::TYPE_RING )
{
lineScatter( geom, geomSRS, context, points.get() );
}
else {
points = static_cast< PointSet*>(geom->cloneAs(Geometry::TYPE_POINTSET));
}
// replace the source geometry with the scattered points.
f->setGeometry( points.get() );
}
return context;
}
FilterContext
BufferFilter::push( FeatureList& input, FilterContext& context )
{
if ( !isSupported() )
{
OE_WARN << "BufferFilter support not enabled - please compile osgEarth with GEOS" << std::endl;
return context;
}
//OE_NOTICE << "Buffer: input = " << input.size() << " features" << std::endl;
for( FeatureList::iterator i = input.begin(); i != input.end(); )
{
Feature* feature = i->get();
if ( !feature || !feature->getGeometry() )
continue;
osg::ref_ptr<Symbology::Geometry> output;
Symbology::BufferParameters params;
params._capStyle =
_capStyle == Stroke::LINECAP_ROUND ? Symbology::BufferParameters::CAP_ROUND :
_capStyle == Stroke::LINECAP_SQUARE ? Symbology::BufferParameters::CAP_SQUARE :
_capStyle == Stroke::LINECAP_FLAT ? Symbology::BufferParameters::CAP_FLAT :
Symbology::BufferParameters::CAP_SQUARE;
params._cornerSegs = _numQuadSegs;
if ( feature->getGeometry()->buffer( _distance.value(), output, params ) )
{
feature->setGeometry( output.get() );
++i;
}
else
{
i = input.erase( i );
OE_DEBUG << LC << "feature " << feature->getFID() << " yielded no geometry" << std::endl;
}
}
return context;
}
FilterContext
ConvertTypeFilter::push( FeatureList& input, FilterContext& context )
{
if ( !isSupported() )
{
OE_WARN << "ConvertTypeFilter support not enabled" << std::endl;
return context;
}
bool ok = true;
for( FeatureList::iterator i = input.begin(); i != input.end(); ++i )
{
Feature* input = i->get();
if ( input && input->getGeometry() && input->getGeometry()->getComponentType() != _toType )
{
input->setGeometry( input->getGeometry()->cloneAs(_toType) );
}
}
return context;
}
std::string Feature::featuresToGeoJSON( FeatureList& features)
{
std::stringstream buf;
buf << "{\"type\": \"FeatureCollection\", \"features\": [";
FeatureList::iterator last = features.end();
last--;
for (FeatureList::iterator i = features.begin(); i != features.end(); i++)
{
buf << i->get()->getGeoJSON();
if (i != last)
{
buf << ",";
}
}
buf << "]}";
return buf.str();
}
void
AltitudeFilter::pushAndDontClamp( FeatureList& features, FilterContext& cx )
{
NumericExpression scaleExpr;
if ( _altitude.valid() && _altitude->verticalScale().isSet() )
scaleExpr = *_altitude->verticalScale();
NumericExpression offsetExpr;
if ( _altitude.valid() && _altitude->verticalOffset().isSet() )
offsetExpr = *_altitude->verticalOffset();
bool gpuClamping =
_altitude.valid() &&
_altitude->technique() == _altitude->TECHNIQUE_GPU;
bool ignoreZ =
gpuClamping &&
_altitude->clamping() == _altitude->CLAMP_TO_TERRAIN;
for( FeatureList::iterator i = features.begin(); i != features.end(); ++i )
{
Feature* feature = i->get();
// run a symbol script if present.
if ( _altitude.valid() && _altitude->script().isSet() )
{
StringExpression temp( _altitude->script().get() );
feature->eval( temp, &cx );
}
double minHAT = DBL_MAX;
double maxHAT = -DBL_MAX;
double scaleZ = 1.0;
if ( _altitude.valid() && _altitude->verticalScale().isSet() )
scaleZ = feature->eval( scaleExpr, &cx );
optional<double> offsetZ( 0.0 );
if ( _altitude.valid() && _altitude->verticalOffset().isSet() )
offsetZ = feature->eval( offsetExpr, &cx );
GeometryIterator gi( feature->getGeometry() );
while( gi.hasMore() )
{
Geometry* geom = gi.next();
for( Geometry::iterator g = geom->begin(); g != geom->end(); ++g )
{
if ( ignoreZ )
{
g->z() = 0.0;
}
if ( !gpuClamping )
{
g->z() *= scaleZ;
g->z() += offsetZ.get();
}
if ( g->z() < minHAT )
minHAT = g->z();
if ( g->z() > maxHAT )
maxHAT = g->z();
}
}
if ( minHAT != DBL_MAX )
{
feature->set( "__min_hat", minHAT );
feature->set( "__max_hat", maxHAT );
}
// encode the Z offset if
if ( gpuClamping )
{
feature->set("__oe_verticalScale", scaleZ);
feature->set("__oe_verticalOffset", offsetZ.get());
}
}
}
bool
BuildGeometryFilter::process( FeatureList& features, const FilterContext& context )
{
bool makeECEF = false;
const SpatialReference* featureSRS = 0L;
const SpatialReference* mapSRS = 0L;
if ( context.isGeoreferenced() )
{
makeECEF = context.getSession()->getMapInfo().isGeocentric();
featureSRS = context.extent()->getSRS();
mapSRS = context.getSession()->getMapInfo().getProfile()->getSRS();
}
for( FeatureList::iterator f = features.begin(); f != features.end(); ++f )
{
Feature* input = f->get();
GeometryIterator parts( input->getGeometry(), false );
while( parts.hasMore() )
{
Geometry* part = parts.next();
// skip empty geometry
if ( part->size() == 0 )
continue;
const Style& myStyle = input->style().isSet() ? *input->style() : _style;
bool setLinePropsHere = input->style().isSet(); // otherwise it will be set globally, we assume
float width = 1.0f;
bool hasPolyOutline = false;
const PointSymbol* pointSymbol = myStyle.get<PointSymbol>();
const LineSymbol* lineSymbol = myStyle.get<LineSymbol>();
const PolygonSymbol* polySymbol = myStyle.get<PolygonSymbol>();
// resolve the geometry type from the component type and the symbology:
Geometry::Type renderType = Geometry::TYPE_UNKNOWN;
// First priority is a matching part type and symbol:
if ( polySymbol != 0L && part->getType() == Geometry::TYPE_POLYGON )
{
renderType = Geometry::TYPE_POLYGON;
}
else if ( lineSymbol != 0L && part->isLinear() )
{
renderType = part->getType();
}
else if ( pointSymbol != 0L && part->getType() == Geometry::TYPE_POINTSET )
{
renderType = Geometry::TYPE_POINTSET;
}
// Second priority is the symbol:
else if ( polySymbol != 0L )
{
renderType = Geometry::TYPE_POLYGON;
}
else if ( lineSymbol != 0L )
{
if ( part->getType() == Geometry::TYPE_POLYGON )
renderType = Geometry::TYPE_RING;
else
renderType = Geometry::TYPE_LINESTRING;
}
else if ( pointSymbol != 0L )
{
renderType = Geometry::TYPE_POINTSET;
}
// No symbol? just use the geometry type.
else
{
renderType = part->getType();
}
// validate the geometry:
if ( renderType == Geometry::TYPE_POLYGON && part->size() < 3 )
continue;
else if ( (renderType == Geometry::TYPE_LINESTRING || renderType == Geometry::TYPE_RING) && part->size() < 2 )
continue;
// resolve the color:
osg::Vec4f primaryColor =
polySymbol ? osg::Vec4f(polySymbol->fill()->color()) :
lineSymbol ? osg::Vec4f(lineSymbol->stroke()->color()) :
pointSymbol ? osg::Vec4f(pointSymbol->fill()->color()) :
osg::Vec4f(1,1,1,1);
osg::Geometry* osgGeom = new osg::Geometry();
osgGeom->setUseVertexBufferObjects( _useVertexBufferObjects.value() );
if ( _featureNameExpr.isSet() )
{
const std::string& name = input->eval( _featureNameExpr.mutable_value(), &context );
osgGeom->setName( name );
}
// build the geometry:
osg::Vec3Array* allPoints = 0L;
if ( renderType == Geometry::TYPE_POLYGON )
{
buildPolygon(part, featureSRS, mapSRS, makeECEF, true, osgGeom);
allPoints = static_cast<osg::Vec3Array*>( osgGeom->getVertexArray() );
}
else
{
// line or point geometry
GLenum primMode =
renderType == Geometry::TYPE_LINESTRING ? GL_LINE_STRIP :
renderType == Geometry::TYPE_RING ? GL_LINE_LOOP :
GL_POINTS;
allPoints = new osg::Vec3Array();
transformAndLocalize( part->asVector(), featureSRS, allPoints, mapSRS, _world2local, makeECEF );
osgGeom->addPrimitiveSet( new osg::DrawArrays( primMode, 0, part->size() ) );
osgGeom->setVertexArray( allPoints );
applyLineAndPointSymbology( osgGeom->getOrCreateStateSet(), lineSymbol, pointSymbol );
if ( primMode == GL_POINTS && allPoints->size() == 1 )
{
const osg::Vec3d& center = (*allPoints)[0];
osgGeom->setInitialBound( osg::BoundingBox(center-osg::Vec3(.5,.5,.5), center+osg::Vec3(.5,.5,.5)) );
}
}
if (allPoints->getVertexBufferObject())
allPoints->getVertexBufferObject()->setUsage(GL_STATIC_DRAW_ARB);
// subdivide the mesh if necessary to conform to an ECEF globe:
if ( makeECEF && renderType != Geometry::TYPE_POINTSET )
{
// check for explicit tessellation disable:
const LineSymbol* line = _style.get<LineSymbol>();
bool disableTess = line && line->tessellation().isSetTo(0);
if ( makeECEF && !disableTess )
{
double threshold = osg::DegreesToRadians( *_maxAngle_deg );
OE_DEBUG << "Running mesh subdivider with threshold " << *_maxAngle_deg << std::endl;
MeshSubdivider ms( _world2local, _local2world );
//ms.setMaxElementsPerEBO( INT_MAX );
if ( input->geoInterp().isSet() )
ms.run( *osgGeom, threshold, *input->geoInterp() );
else
ms.run( *osgGeom, threshold, *_geoInterp );
}
}
// assign the primary color:
#if USE_SINGLE_COLOR
osg::Vec4Array* colors = new osg::Vec4Array( 1 );
(*colors)[0] = primaryColor;
osgGeom->setColorBinding( osg::Geometry::BIND_OVERALL );
#else
osg::Vec4Array* colors = new osg::Vec4Array( osgGeom->getVertexArray()->getNumElements() ); //allPoints->size() );
for(unsigned c=0; c<colors->size(); ++c)
(*colors)[c] = primaryColor;
osgGeom->setColorBinding( osg::Geometry::BIND_PER_VERTEX );
#endif
osgGeom->setColorArray( colors );
_geode->addDrawable( osgGeom );
// record the geometry's primitive set(s) in the index:
if ( context.featureIndex() )
context.featureIndex()->tagPrimitiveSets( osgGeom, input );
// build secondary geometry, if necessary (polygon outlines)
if ( renderType == Geometry::TYPE_POLYGON && lineSymbol )
{
// polygon offset on the poly so the outline doesn't z-fight
osgGeom->getOrCreateStateSet()->setAttributeAndModes( new osg::PolygonOffset(1,1), 1 );
osg::Geometry* outline = new osg::Geometry();
outline->setUseVertexBufferObjects( _useVertexBufferObjects.value() );
buildPolygon(part, featureSRS, mapSRS, makeECEF, false, outline);
if ( outline->getVertexArray()->getVertexBufferObject() )
outline->getVertexArray()->getVertexBufferObject()->setUsage(GL_STATIC_DRAW_ARB);
osg::Vec4f outlineColor = lineSymbol->stroke()->color();
osg::Vec4Array* outlineColors = new osg::Vec4Array();
#if USE_SINGLE_COLOR
outlineColors->reserve(1);
outlineColors->push_back( outlineColor );
outline->setColorBinding( osg::Geometry::BIND_OVERALL );
#else
unsigned pcount = part->getTotalPointCount();
outlineColors->reserve( pcount );
for( unsigned c=0; c < pcount; ++c )
outlineColors->push_back( outlineColor );
outline->setColorBinding( osg::Geometry::BIND_PER_VERTEX );
#endif
outline->setColorArray(outlineColors);
// check for explicit tessellation disable:
bool disableTess = lineSymbol && lineSymbol->tessellation().isSetTo(0);
// subdivide if necessary.
if ( makeECEF && !disableTess )
{
double threshold = osg::DegreesToRadians( *_maxAngle_deg );
OE_DEBUG << "Running mesh subdivider for outlines with threshold " << *_maxAngle_deg << std::endl;
MeshSubdivider ms( _world2local, _local2world );
if ( input->geoInterp().isSet() )
ms.run( *outline, threshold, *input->geoInterp() );
else
ms.run( *outline, threshold, *_geoInterp );
}
applyLineAndPointSymbology( outline->getOrCreateStateSet(), lineSymbol, 0L );
// make normals before adding an outline
osgUtil::SmoothingVisitor sv;
_geode->accept( sv );
_geode->addDrawable( outline );
//_featureNode->addDrawable( outline, input->getFID() );
// Mark each primitive set with its feature ID.
if ( context.featureIndex() )
context.featureIndex()->tagPrimitiveSets( outline, input );
}
}
}
return true;
}
bool
ExtrudeGeometryFilter::process( FeatureList& features, FilterContext& context )
{
// seed our random number generators
Random wallSkinPRNG( _wallSkinSymbol.valid()? *_wallSkinSymbol->randomSeed() : 0, Random::METHOD_FAST );
Random roofSkinPRNG( _roofSkinSymbol.valid()? *_roofSkinSymbol->randomSeed() : 0, Random::METHOD_FAST );
for( FeatureList::iterator f = features.begin(); f != features.end(); ++f )
{
Feature* input = f->get();
GeometryIterator iter( input->getGeometry(), false );
while( iter.hasMore() )
{
Geometry* part = iter.next();
osg::ref_ptr<osg::Geometry> walls = new osg::Geometry();
walls->setUseVertexBufferObjects( _useVertexBufferObjects.get() );
osg::ref_ptr<osg::Geometry> rooflines = 0L;
osg::ref_ptr<osg::Geometry> baselines = 0L;
osg::ref_ptr<osg::Geometry> outlines = 0L;
if ( part->getType() == Geometry::TYPE_POLYGON )
{
rooflines = new osg::Geometry();
rooflines->setUseVertexBufferObjects( _useVertexBufferObjects.get() );
// prep the shapes by making sure all polys are open:
static_cast<Polygon*>(part)->open();
}
// fire up the outline geometry if we have a line symbol.
if ( _outlineSymbol != 0L )
{
outlines = new osg::Geometry();
outlines->setUseVertexBufferObjects( _useVertexBufferObjects.get() );
}
// make a base cap if we're doing stencil volumes.
if ( _makeStencilVolume )
{
baselines = new osg::Geometry();
baselines->setUseVertexBufferObjects( _useVertexBufferObjects.get() );
}
// calculate the extrusion height:
float height;
if ( _heightCallback.valid() )
{
height = _heightCallback->operator()(input, context);
}
else if ( _heightExpr.isSet() )
{
height = input->eval( _heightExpr.mutable_value(), &context );
}
else
{
height = *_extrusionSymbol->height();
}
// calculate the height offset from the base:
float offset = 0.0;
if ( _heightOffsetExpr.isSet() )
{
offset = input->eval( _heightOffsetExpr.mutable_value(), &context );
}
osg::ref_ptr<osg::StateSet> wallStateSet;
osg::ref_ptr<osg::StateSet> roofStateSet;
// calculate the wall texturing:
SkinResource* wallSkin = 0L;
if ( _wallSkinSymbol.valid() )
{
if ( _wallResLib.valid() )
{
SkinSymbol querySymbol( *_wallSkinSymbol.get() );
querySymbol.objectHeight() = fabs(height) - offset;
wallSkin = _wallResLib->getSkin( &querySymbol, wallSkinPRNG, context.getDBOptions() );
}
else
{
//TODO: simple single texture?
}
}
// calculate the rooftop texture:
SkinResource* roofSkin = 0L;
if ( _roofSkinSymbol.valid() )
{
if ( _roofResLib.valid() )
{
SkinSymbol querySymbol( *_roofSkinSymbol.get() );
roofSkin = _roofResLib->getSkin( &querySymbol, roofSkinPRNG, context.getDBOptions() );
}
else
{
//TODO: simple single texture?
}
}
// Build the data model for the structure.
Structure structure;
buildStructure(
part,
height,
offset,
_extrusionSymbol->flatten().get(),
wallSkin,
roofSkin,
structure,
context);
// Create the walls.
if ( walls.valid() )
{
osg::Vec4f wallColor(1,1,1,1), wallBaseColor(1,1,1,1);
if ( _wallPolygonSymbol.valid() )
{
wallColor = _wallPolygonSymbol->fill()->color();
}
if ( _extrusionSymbol->wallGradientPercentage().isSet() )
{
wallBaseColor = Color(wallColor).brightness( 1.0 - *_extrusionSymbol->wallGradientPercentage() );
}
else
{
wallBaseColor = wallColor;
}
buildWallGeometry(structure, walls.get(), wallColor, wallBaseColor, wallSkin);
if ( wallSkin )
{
// Get a stateset for the individual wall stateset
context.resourceCache()->getOrCreateStateSet( wallSkin, wallStateSet );
}
}
// tessellate and add the roofs if necessary:
if ( rooflines.valid() )
{
osg::Vec4f roofColor(1,1,1,1);
if ( _roofPolygonSymbol.valid() )
{
roofColor = _roofPolygonSymbol->fill()->color();
}
buildRoofGeometry(structure, rooflines.get(), roofColor, roofSkin);
if ( roofSkin )
{
// Get a stateset for the individual roof skin
context.resourceCache()->getOrCreateStateSet( roofSkin, roofStateSet );
}
}
if ( outlines.valid() )
{
osg::Vec4f outlineColor(1,1,1,1);
if ( _outlineSymbol.valid() )
{
outlineColor = _outlineSymbol->stroke()->color();
}
float minCreaseAngle = _outlineSymbol->creaseAngle().value();
buildOutlineGeometry(structure, outlines.get(), outlineColor, minCreaseAngle);
}
if ( baselines.valid() )
{
//TODO.
osgUtil::Tessellator tess;
tess.setTessellationType( osgUtil::Tessellator::TESS_TYPE_GEOMETRY );
tess.setWindingType( osgUtil::Tessellator::TESS_WINDING_ODD );
tess.retessellatePolygons( *(baselines.get()) );
}
// Set up for feature naming and feature indexing:
std::string name;
if ( !_featureNameExpr.empty() )
name = input->eval( _featureNameExpr, &context );
FeatureSourceIndex* index = context.featureIndex();
if ( walls.valid() )
{
addDrawable( walls.get(), wallStateSet.get(), name, input, index );
}
if ( rooflines.valid() )
{
addDrawable( rooflines.get(), roofStateSet.get(), name, input, index );
}
if ( baselines.valid() )
{
addDrawable( baselines.get(), 0L, name, input, index );
}
if ( outlines.valid() )
{
addDrawable( outlines.get(), 0L, name, input, index );
}
}
}
return true;
}
//clustering:
// troll the external model for geodes. for each geode, create a geode in the target
// model. then, for each geometry in that geode, replicate it once for each instance of
// the model in the feature batch and transform the actual verts to a local offset
// relative to the tile centroid. Finally, reassemble all the geodes and optimize.
// hopefully stateset sharing etc will work out. we may need to strip out LODs too.
bool
SubstituteModelFilter::cluster(const FeatureList& features,
const MarkerSymbol* symbol,
Session* session,
osg::Group* attachPoint,
FilterContext& context )
{
MarkerToFeatures markerToFeatures;
// first, sort the features into buckets, each bucket corresponding to a
// unique marker.
for (FeatureList::const_iterator i = features.begin(); i != features.end(); ++i)
{
Feature* f = i->get();
// resolve the URI for the marker:
StringExpression uriEx( *symbol->url() );
URI markerURI( f->eval( uriEx, &context ), uriEx.uriContext() );
// find and load the corresponding marker model. We're using the session-level
// object store to cache models. This is thread-safe sine we are always going
// to CLONE the model before using it.
osg::ref_ptr<osg::Node> model = context.getSession()->getObject<osg::Node>( markerURI.full() );
if ( !model.valid() )
{
osg::ref_ptr<MarkerResource> mres = new MarkerResource();
mres->uri() = markerURI;
model = mres->createNode( context.getSession()->getDBOptions() );
if ( model.valid() )
{
// store it, but only if there isn't already one in there.
context.getSession()->putObject( markerURI.full(), model.get(), false );
}
}
if ( model.valid() )
{
MarkerToFeatures::iterator itr = markerToFeatures.find( model.get() );
if (itr == markerToFeatures.end())
markerToFeatures[ model.get() ].push_back( f );
else
itr->second.push_back( f );
}
}
//For each model, cluster the features that use that marker
for (MarkerToFeatures::iterator i = markerToFeatures.begin(); i != markerToFeatures.end(); ++i)
{
osg::Node* prototype = i->first;
// we're using the Session cache since we know we'll be cloning.
if ( prototype )
{
osg::Node* clone = osg::clone( prototype, osg::CopyOp::DEEP_COPY_ALL );
// ..and apply the clustering to the copy.
ClusterVisitor cv( i->second, symbol, this, context );
clone->accept( cv );
attachPoint->addChild( clone );
}
}
return true;
}
bool
SubstituteModelFilter::process(const FeatureList& features,
const InstanceSymbol* symbol,
Session* session,
osg::Group* attachPoint,
FilterContext& context )
{
// Establish SRS information:
bool makeECEF = context.getSession()->getMapInfo().isGeocentric();
const SpatialReference* targetSRS = context.getSession()->getMapInfo().getSRS();
// first, go through the features and build the model cache. Apply the model matrix' scale
// factor to any AutoTransforms directly (cloning them as necessary)
std::map< std::pair<URI, float>, osg::ref_ptr<osg::Node> > uniqueModels;
// keep track of failed URIs so we don't waste time or warning messages on them
std::set< URI > missing;
StringExpression uriEx = *symbol->url();
NumericExpression scaleEx = *symbol->scale();
const ModelSymbol* modelSymbol = dynamic_cast<const ModelSymbol*>(symbol);
const IconSymbol* iconSymbol = dynamic_cast<const IconSymbol*> (symbol);
NumericExpression headingEx;
if ( modelSymbol )
headingEx = *modelSymbol->heading();
for( FeatureList::const_iterator f = features.begin(); f != features.end(); ++f )
{
Feature* input = f->get();
// evaluate the instance URI expression:
StringExpression uriEx = *symbol->url();
URI instanceURI( input->eval(uriEx, &context), uriEx.uriContext() );
// find the corresponding marker in the cache
osg::ref_ptr<InstanceResource> instance;
if ( !findResource(instanceURI, symbol, context, missing, instance) )
continue;
// evalute the scale expression (if there is one)
float scale = 1.0f;
osg::Matrixd scaleMatrix;
if ( symbol->scale().isSet() )
{
scale = input->eval( scaleEx, &context );
if ( scale == 0.0 )
scale = 1.0;
if ( scale != 1.0 )
_normalScalingRequired = true;
scaleMatrix = osg::Matrix::scale( scale, scale, scale );
}
osg::Matrixd rotationMatrix;
if ( modelSymbol && modelSymbol->heading().isSet() )
{
float heading = input->eval(headingEx, &context);
rotationMatrix.makeRotate( osg::Quat(osg::DegreesToRadians(heading), osg::Vec3(0,0,1)) );
}
// how that we have a marker source, create a node for it
std::pair<URI,float> key( instanceURI, scale );
// cache nodes per instance.
osg::ref_ptr<osg::Node>& model = uniqueModels[key];
if ( !model.valid() )
{
context.resourceCache()->getInstanceNode( instance.get(), model );
// if icon decluttering is off, install an AutoTransform.
if ( iconSymbol )
{
if ( iconSymbol->declutter() == true )
{
Decluttering::setEnabled( model->getOrCreateStateSet(), true );
}
else if ( dynamic_cast<osg::AutoTransform*>(model.get()) == 0L )
{
osg::AutoTransform* at = new osg::AutoTransform();
at->setAutoRotateMode( osg::AutoTransform::ROTATE_TO_SCREEN );
at->setAutoScaleToScreen( true );
at->addChild( model );
model = at;
}
}
}
if ( model.valid() )
{
GeometryIterator gi( input->getGeometry(), false );
while( gi.hasMore() )
{
Geometry* geom = gi.next();
// if necessary, transform the points to the target SRS:
if ( !makeECEF && !targetSRS->isEquivalentTo(context.profile()->getSRS()) )
{
context.profile()->getSRS()->transform( geom->asVector(), targetSRS );
}
for( unsigned i=0; i<geom->size(); ++i )
{
osg::Matrixd mat;
osg::Vec3d point = (*geom)[i];
if ( makeECEF )
{
// the "rotation" element lets us re-orient the instance to ensure it's pointing up. We
// could take a shortcut and just use the current extent's local2world matrix for this,
// but if the tile is big enough the up vectors won't be quite right.
osg::Matrixd rotation;
ECEF::transformAndGetRotationMatrix( point, context.profile()->getSRS(), point, targetSRS, rotation );
mat = rotationMatrix * rotation * scaleMatrix * osg::Matrixd::translate( point ) * _world2local;
}
else
{
mat = rotationMatrix * scaleMatrix * osg::Matrixd::translate( point ) * _world2local;
}
osg::MatrixTransform* xform = new osg::MatrixTransform();
xform->setMatrix( mat );
xform->setDataVariance( osg::Object::STATIC );
xform->addChild( model.get() );
attachPoint->addChild( xform );
if ( context.featureIndex() && !_useDrawInstanced )
{
context.featureIndex()->tagNode( xform, input );
}
// name the feature if necessary
if ( !_featureNameExpr.empty() )
{
const std::string& name = input->eval( _featureNameExpr, &context);
if ( !name.empty() )
xform->setName( name );
}
}
}
}
}
if ( iconSymbol )
{
// activate decluttering for icons if requested
if ( iconSymbol->declutter() == true )
{
Decluttering::setEnabled( attachPoint->getOrCreateStateSet(), true );
}
// activate horizon culling if we are in geocentric space
if ( context.getSession() && context.getSession()->getMapInfo().isGeocentric() )
{
HorizonCullingProgram::install( attachPoint->getOrCreateStateSet() );
}
}
// active DrawInstanced if required:
if ( _useDrawInstanced && Registry::capabilities().supportsDrawInstanced() )
{
DrawInstanced::convertGraphToUseDrawInstanced( attachPoint );
// install a shader program to render draw-instanced.
DrawInstanced::install( attachPoint->getOrCreateStateSet() );
}
return true;
}
osg::HeightField* createHeightField( const TileKey& key,
ProgressCallback* progress)
{
if (key.getLevelOfDetail() > _maxDataLevel)
{
//OE_NOTICE << "Reached maximum data resolution key=" << key.getLevelOfDetail() << " max=" << _maxDataLevel << std::endl;
return NULL;
}
int tileSize = _options.tileSize().value();
//Allocate the heightfield
osg::ref_ptr<osg::HeightField> hf = new osg::HeightField;
hf->allocate(tileSize, tileSize);
for (unsigned int i = 0; i < hf->getHeightList().size(); ++i) hf->getHeightList()[i] = NO_DATA_VALUE;
if (intersects(key))
{
//Get the extents of the tile
double xmin, ymin, xmax, ymax;
key.getExtent().getBounds(xmin, ymin, xmax, ymax);
const SpatialReference* featureSRS = _features->getFeatureProfile()->getSRS();
GeoExtent extentInFeatureSRS = key.getExtent().transform( featureSRS );
const SpatialReference* keySRS = key.getProfile()->getSRS();
// populate feature list
// assemble a spatial query. It helps if your features have a spatial index.
Query query;
query.bounds() = extentInFeatureSRS.bounds();
FeatureList featureList;
osg::ref_ptr<FeatureCursor> cursor = _features->createFeatureCursor(query);
while ( cursor.valid() && cursor->hasMore() )
{
Feature* f = cursor->nextFeature();
if ( f && f->getGeometry() )
featureList.push_back(f);
}
// We now have a feature list in feature SRS.
bool transformRequired = !keySRS->isHorizEquivalentTo(featureSRS);
if (!featureList.empty())
{
// Iterate over the output heightfield and sample the data that was read into it.
double dx = (xmax - xmin) / (tileSize-1);
double dy = (ymax - ymin) / (tileSize-1);
for (int c = 0; c < tileSize; ++c)
{
double geoX = xmin + (dx * (double)c);
for (int r = 0; r < tileSize; ++r)
{
double geoY = ymin + (dy * (double)r);
float h = NO_DATA_VALUE;
for (FeatureList::iterator f = featureList.begin(); f != featureList.end(); ++f)
{
osgEarth::Symbology::Polygon* boundary = dynamic_cast<osgEarth::Symbology::Polygon*>((*f)->getGeometry());
if (!boundary)
{
OE_WARN << LC << "NOT A POLYGON" << std::endl;
}
else
{
GeoPoint geo(keySRS, geoX, geoY, 0.0, ALTMODE_ABSOLUTE);
if ( transformRequired )
geo = geo.transform(featureSRS);
if ( boundary->contains2D(geo.x(), geo.y()) )
{
h = (*f)->getDouble(_options.attr().value());
if ( keySRS->isGeographic() )
{
// for a round earth, must adjust the final elevation accounting for the
// curvature of the earth; so we have to adjust it in the feature boundary's
// local tangent plane.
Bounds bounds = boundary->getBounds();
GeoPoint anchor( featureSRS, bounds.center().x(), bounds.center().y(), h, ALTMODE_ABSOLUTE );
if ( transformRequired )
anchor = anchor.transform(keySRS);
// For transforming between ECEF and local tangent plane:
osg::Matrix localToWorld, worldToLocal;
anchor.createLocalToWorld(localToWorld);
worldToLocal.invert( localToWorld );
// Get the ECEF location of the anchor point:
osg::Vec3d ecef;
geo.toWorld( ecef );
// Move it into Local Tangent Plane coordinates:
osg::Vec3d local = ecef * worldToLocal;
// Reset the Z to zero, since the LTP is centered on the "h" elevation:
local.z() = 0.0;
// Back into ECEF:
ecef = local * localToWorld;
// And back into lat/long/alt:
geo.fromWorld( geo.getSRS(), ecef);
h = geo.z();
}
break;
}
}
}
hf->setHeight(c, r, h-0.1);
}
}
}
}
return hf.release();
}
void
AltitudeFilter::pushAndClamp( FeatureList& features, FilterContext& cx )
{
const Session* session = cx.getSession();
// the map against which we'll be doing elevation clamping
//MapFrame mapf = session->createMapFrame( Map::ELEVATION_LAYERS );
MapFrame mapf = session->createMapFrame(
(Map::ModelParts)(Map::TERRAIN_LAYERS | Map::MODEL_LAYERS) );
const SpatialReference* mapSRS = mapf.getProfile()->getSRS();
osg::ref_ptr<const SpatialReference> featureSRS = cx.profile()->getSRS();
// establish an elevation query interface based on the features' SRS.
ElevationQuery eq( mapf );
// want a result even if it's low res
eq.setFallBackOnNoData( true );
NumericExpression scaleExpr;
if ( _altitude->verticalScale().isSet() )
scaleExpr = *_altitude->verticalScale();
NumericExpression offsetExpr;
if ( _altitude->verticalOffset().isSet() )
offsetExpr = *_altitude->verticalOffset();
// whether to record the min/max height-above-terrain values.
bool collectHATs =
_altitude->clamping() == AltitudeSymbol::CLAMP_RELATIVE_TO_TERRAIN ||
_altitude->clamping() == AltitudeSymbol::CLAMP_ABSOLUTE;
// whether to clamp every vertex (or just the centroid)
bool perVertex =
_altitude->binding() == AltitudeSymbol::BINDING_VERTEX;
// whether the SRS's have a compatible vertical datum.
bool vertEquiv =
featureSRS->isVertEquivalentTo( mapSRS );
for( FeatureList::iterator i = features.begin(); i != features.end(); ++i )
{
Feature* feature = i->get();
// run a symbol script if present.
if ( _altitude.valid() && _altitude->script().isSet() )
{
StringExpression temp( _altitude->script().get() );
feature->eval( temp, &cx );
}
double maxTerrainZ = -DBL_MAX;
double minTerrainZ = DBL_MAX;
double minHAT = DBL_MAX;
double maxHAT = -DBL_MAX;
double scaleZ = 1.0;
if ( _altitude.valid() && _altitude->verticalScale().isSet() )
scaleZ = feature->eval( scaleExpr, &cx );
double offsetZ = 0.0;
if ( _altitude.valid() && _altitude->verticalOffset().isSet() )
offsetZ = feature->eval( offsetExpr, &cx );
GeometryIterator gi( feature->getGeometry() );
while( gi.hasMore() )
{
Geometry* geom = gi.next();
// Absolute heights in Z. Only need to collect the HATs; the geometry
// remains unchanged.
if ( _altitude->clamping() == AltitudeSymbol::CLAMP_ABSOLUTE )
{
if ( perVertex )
{
std::vector<double> elevations;
elevations.reserve( geom->size() );
if ( eq.getElevations( geom->asVector(), featureSRS, elevations, _maxRes ) )
{
for( unsigned i=0; i<geom->size(); ++i )
{
osg::Vec3d& p = (*geom)[i];
p.z() *= scaleZ;
p.z() += offsetZ;
double z = p.z();
if ( !vertEquiv )
{
osg::Vec3d tempgeo;
if ( !featureSRS->transform(p, mapSRS->getGeographicSRS(), tempgeo) )
z = tempgeo.z();
}
double hat = z - elevations[i];
if ( hat > maxHAT )
maxHAT = hat;
if ( hat < minHAT )
minHAT = hat;
if ( elevations[i] > maxTerrainZ )
maxTerrainZ = elevations[i];
if ( elevations[i] < minTerrainZ )
minTerrainZ = elevations[i];
}
}
}
else // per centroid
{
osgEarth::Bounds bounds = geom->getBounds();
const osg::Vec2d& center = bounds.center2d();
GeoPoint centroid(featureSRS, center.x(), center.y());
double centroidElevation;
if ( eq.getElevation( centroid, centroidElevation, _maxRes ) )
{
for( unsigned i=0; i<geom->size(); ++i )
{
osg::Vec3d& p = (*geom)[i];
p.z() *= scaleZ;
p.z() += offsetZ;
double z = p.z();
if ( !vertEquiv )
{
osg::Vec3d tempgeo;
if ( !featureSRS->transform(p, mapSRS->getGeographicSRS(), tempgeo) )
z = tempgeo.z();
}
double hat = z - centroidElevation;
if ( hat > maxHAT )
maxHAT = hat;
if ( hat < minHAT )
minHAT = hat;
}
if ( centroidElevation > maxTerrainZ )
maxTerrainZ = centroidElevation;
if ( centroidElevation < minTerrainZ )
minTerrainZ = centroidElevation;
}
}
}
// Heights-above-ground in Z. Need to resolve this to an absolute number
// and record HATs along the way.
else if ( _altitude->clamping() == AltitudeSymbol::CLAMP_RELATIVE_TO_TERRAIN )
{
osg::ref_ptr<const SpatialReference> featureSRSwithMapVertDatum = !vertEquiv ?
SpatialReference::create(featureSRS->getHorizInitString(), mapSRS->getVertInitString()) : 0L;
if ( perVertex )
{
std::vector<double> elevations;
elevations.reserve( geom->size() );
if ( eq.getElevations( geom->asVector(), featureSRS, elevations, _maxRes ) )
{
for( unsigned i=0; i<geom->size(); ++i )
{
osg::Vec3d& p = (*geom)[i];
p.z() *= scaleZ;
p.z() += offsetZ;
double hat = p.z();
p.z() = elevations[i] + p.z();
// if necessary, convert the Z value (which is now in the map's SRS) back to
// the feature's SRS.
if ( !vertEquiv )
{
featureSRSwithMapVertDatum->transform(p, featureSRS, p);
}
if ( hat > maxHAT )
maxHAT = hat;
if ( hat < minHAT )
minHAT = hat;
if ( elevations[i] > maxTerrainZ )
maxTerrainZ = elevations[i];
if ( elevations[i] < minTerrainZ )
minTerrainZ = elevations[i];
}
}
}
else // per-centroid
{
osgEarth::Bounds bounds = geom->getBounds();
const osg::Vec2d& center = bounds.center2d();
GeoPoint centroid(featureSRS, center.x(), center.y());
double centroidElevation;
if ( eq.getElevation( centroid, centroidElevation, _maxRes ) )
{
for( unsigned i=0; i<geom->size(); ++i )
{
osg::Vec3d& p = (*geom)[i];
p.z() *= scaleZ;
p.z() += offsetZ;
double hat = p.z();
p.z() = centroidElevation + p.z();
// if necessary, convert the Z value (which is now in the map's SRS) back to
// the feature's SRS.
if ( !vertEquiv )
{
featureSRSwithMapVertDatum->transform(p, featureSRS, p);
}
if ( hat > maxHAT )
maxHAT = hat;
if ( hat < minHAT )
minHAT = hat;
}
if ( centroidElevation > maxTerrainZ )
maxTerrainZ = centroidElevation;
if ( centroidElevation < minTerrainZ )
minTerrainZ = centroidElevation;
}
}
}
// Clamp - replace the geometry's Z with the terrain height.
else // CLAMP_TO_TERRAIN
{
if ( perVertex )
{
eq.getElevations( geom->asVector(), featureSRS, true, _maxRes );
// if necessary, transform the Z values (which are now in the map SRS) back
// into the feature's SRS.
if ( !vertEquiv )
{
osg::ref_ptr<const SpatialReference> featureSRSwithMapVertDatum =
SpatialReference::create(featureSRS->getHorizInitString(), mapSRS->getVertInitString());
osg::Vec3d tempgeo;
for( unsigned i=0; i<geom->size(); ++i )
{
osg::Vec3d& p = (*geom)[i];
featureSRSwithMapVertDatum->transform(p, featureSRS, p);
}
}
}
else // per-centroid
{
osgEarth::Bounds bounds = geom->getBounds();
const osg::Vec2d& center = bounds.center2d();
GeoPoint centroid(featureSRS, center.x(), center.y());
double centroidElevation;
osg::ref_ptr<const SpatialReference> featureSRSWithMapVertDatum;
if ( !vertEquiv )
featureSRSWithMapVertDatum = SpatialReference::create(featureSRS->getHorizInitString(), mapSRS->getVertInitString());
if ( eq.getElevation( centroid, centroidElevation, _maxRes ) )
{
for( unsigned i=0; i<geom->size(); ++i )
{
osg::Vec3d& p = (*geom)[i];
p.z() = centroidElevation;
if ( !vertEquiv )
{
featureSRSWithMapVertDatum->transform(p, featureSRS, p);
}
}
}
}
}
if ( !collectHATs )
{
for( Geometry::iterator i = geom->begin(); i != geom->end(); ++i )
{
i->z() *= scaleZ;
i->z() += offsetZ;
}
}
}
if ( minHAT != DBL_MAX )
{
feature->set( "__min_hat", minHAT );
feature->set( "__max_hat", maxHAT );
}
if ( minTerrainZ != DBL_MAX )
{
feature->set( "__min_terrain_z", minTerrainZ );
feature->set( "__max_terrain_z", maxTerrainZ );
}
}
}
bool
FeatureGridder::cullFeatureListToCell( int i, FeatureList& features ) const
{
bool success = true;
int inCount = features.size();
Bounds b;
if ( getCellBounds( i, b ) )
{
if ( _policy.cullingTechnique() == GriddingPolicy::CULL_BY_CENTROID )
{
for( FeatureList::iterator f_i = features.begin(); f_i != features.end(); )
{
bool keepFeature = false;
Feature* feature = f_i->get();
Symbology::Geometry* featureGeom = feature->getGeometry();
if ( featureGeom )
{
osg::Vec3d centroid = featureGeom->getBounds().center();
if ( b.contains( centroid.x(), centroid.y() ) )
{
keepFeature = true;
}
}
if ( keepFeature )
++f_i;
else
f_i = features.erase( f_i );
}
}
else // CULL_BY_CROPPING (requires GEOS)
{
#ifdef OSGEARTH_HAVE_GEOS
// create the intersection polygon:
osg::ref_ptr<Symbology::Polygon> poly = new Symbology::Polygon( 4 );
poly->push_back( osg::Vec3d( b.xMin(), b.yMin(), 0 ));
poly->push_back( osg::Vec3d( b.xMax(), b.yMin(), 0 ));
poly->push_back( osg::Vec3d( b.xMax(), b.yMax(), 0 ));
poly->push_back( osg::Vec3d( b.xMin(), b.yMax(), 0 ));
for( FeatureList::iterator f_i = features.begin(); f_i != features.end(); )
{
bool keepFeature = false;
Feature* feature = f_i->get();
Symbology::Geometry* featureGeom = feature->getGeometry();
if ( featureGeom )
{
osg::ref_ptr<Symbology::Geometry> croppedGeometry;
if ( featureGeom->crop( poly.get(), croppedGeometry ) )
{
feature->setGeometry( croppedGeometry.get() );
keepFeature = true;
}
}
if ( keepFeature )
++f_i;
else
f_i = features.erase( f_i );
}
#endif // OSGEARTH_HAVE_GEOS
}
}
OE_INFO << LC
<< "Grid cell " << i << ": bounds="
<< b.xMin() << "," << b.yMin() << " => " << b.xMax() << "," << b.yMax()
<< "; in=" << inCount << "; out=" << features.size()
<< std::endl;
return success;
}
bool
ExtrudeGeometryFilter::process( FeatureList& features, FilterContext& context )
{
// seed our random number generators
Random wallSkinPRNG( _wallSkinSymbol.valid()? *_wallSkinSymbol->randomSeed() : 0, Random::METHOD_FAST );
Random roofSkinPRNG( _roofSkinSymbol.valid()? *_roofSkinSymbol->randomSeed() : 0, Random::METHOD_FAST );
for( FeatureList::iterator f = features.begin(); f != features.end(); ++f )
{
Feature* input = f->get();
GeometryIterator iter( input->getGeometry(), false );
while( iter.hasMore() )
{
Geometry* part = iter.next();
osg::ref_ptr<osg::Geometry> walls = new osg::Geometry();
walls->setUseVertexBufferObjects( _useVertexBufferObjects.get() );
osg::ref_ptr<osg::Geometry> rooflines = 0L;
osg::ref_ptr<osg::Geometry> baselines = 0L;
osg::ref_ptr<osg::Geometry> outlines = 0L;
if ( part->getType() == Geometry::TYPE_POLYGON )
{
rooflines = new osg::Geometry();
rooflines->setUseVertexBufferObjects( _useVertexBufferObjects.get() );
// prep the shapes by making sure all polys are open:
static_cast<Polygon*>(part)->open();
}
// fire up the outline geometry if we have a line symbol.
if ( _outlineSymbol != 0L )
{
outlines = new osg::Geometry();
outlines->setUseVertexBufferObjects( _useVertexBufferObjects.get() );
}
// make a base cap if we're doing stencil volumes.
if ( _makeStencilVolume )
{
baselines = new osg::Geometry();
baselines->setUseVertexBufferObjects( _useVertexBufferObjects.get() );
}
// calculate the extrusion height:
float height;
if ( _heightCallback.valid() )
{
height = _heightCallback->operator()(input, context);
}
else if ( _heightExpr.isSet() )
{
height = input->eval( _heightExpr.mutable_value(), &context );
}
else
{
height = *_extrusionSymbol->height();
}
// calculate the height offset from the base:
float offset = 0.0;
if ( _heightOffsetExpr.isSet() )
{
offset = input->eval( _heightOffsetExpr.mutable_value(), &context );
}
osg::ref_ptr<osg::StateSet> wallStateSet;
osg::ref_ptr<osg::StateSet> roofStateSet;
// calculate the wall texturing:
SkinResource* wallSkin = 0L;
if ( _wallSkinSymbol.valid() )
{
if ( _wallResLib.valid() )
{
SkinSymbol querySymbol( *_wallSkinSymbol.get() );
querySymbol.objectHeight() = fabs(height) - offset;
wallSkin = _wallResLib->getSkin( &querySymbol, wallSkinPRNG, context.getDBOptions() );
}
else
{
//TODO: simple single texture?
}
}
// calculate the rooftop texture:
SkinResource* roofSkin = 0L;
if ( _roofSkinSymbol.valid() )
{
if ( _roofResLib.valid() )
{
SkinSymbol querySymbol( *_roofSkinSymbol.get() );
roofSkin = _roofResLib->getSkin( &querySymbol, roofSkinPRNG, context.getDBOptions() );
}
else
{
//TODO: simple single texture?
}
}
// calculate the colors:
osg::Vec4f wallColor(1,1,1,0), wallBaseColor(1,1,1,0), roofColor(1,1,1,0), outlineColor(1,1,1,1);
if ( _wallPolygonSymbol.valid() )
{
wallColor = _wallPolygonSymbol->fill()->color();
if ( _extrusionSymbol->wallGradientPercentage().isSet() )
{
wallBaseColor = Color(wallColor).brightness( 1.0 - *_extrusionSymbol->wallGradientPercentage() );
}
else
{
wallBaseColor = wallColor;
}
}
if ( _roofPolygonSymbol.valid() )
{
roofColor = _roofPolygonSymbol->fill()->color();
}
if ( _outlineSymbol.valid() )
{
outlineColor = _outlineSymbol->stroke()->color();
}
// Create the extruded geometry!
if (extrudeGeometry(
part, height, offset,
*_extrusionSymbol->flatten(),
walls.get(), rooflines.get(), baselines.get(), outlines.get(),
wallColor, wallBaseColor, roofColor, outlineColor,
wallSkin, roofSkin,
context ) )
{
if ( wallSkin )
{
context.resourceCache()->getStateSet( wallSkin, wallStateSet );
}
// generate per-vertex normals, altering the geometry as necessary to avoid
// smoothing around sharp corners
osgUtil::SmoothingVisitor::smooth(
*walls.get(),
osg::DegreesToRadians(_wallAngleThresh_deg) );
// tessellate and add the roofs if necessary:
if ( rooflines.valid() )
{
osgUtil::Tessellator tess;
tess.setTessellationType( osgUtil::Tessellator::TESS_TYPE_GEOMETRY );
tess.setWindingType( osgUtil::Tessellator::TESS_WINDING_ODD );
tess.retessellatePolygons( *(rooflines.get()) );
// generate default normals (no crease angle necessary; they are all pointing up)
// TODO do this manually; probably faster
if ( !_makeStencilVolume )
osgUtil::SmoothingVisitor::smooth( *rooflines.get() );
if ( roofSkin )
{
context.resourceCache()->getStateSet( roofSkin, roofStateSet );
}
}
if ( baselines.valid() )
{
osgUtil::Tessellator tess;
tess.setTessellationType( osgUtil::Tessellator::TESS_TYPE_GEOMETRY );
tess.setWindingType( osgUtil::Tessellator::TESS_WINDING_ODD );
tess.retessellatePolygons( *(baselines.get()) );
}
std::string name;
if ( !_featureNameExpr.empty() )
name = input->eval( _featureNameExpr, &context );
FeatureSourceIndex* index = context.featureIndex();
addDrawable( walls.get(), wallStateSet.get(), name, input, index );
if ( rooflines.valid() )
{
addDrawable( rooflines.get(), roofStateSet.get(), name, input, index );
}
if ( baselines.valid() )
{
addDrawable( baselines.get(), 0L, name, input, index );
}
if ( outlines.valid() )
{
addDrawable( outlines.get(), 0L, name, input, index );
}
}
}
}
return true;
}
bool
SubstituteModelFilter::process(const FeatureList& features,
const MarkerSymbol* symbol,
Session* session,
osg::Group* attachPoint,
FilterContext& context )
{
bool makeECEF = context.getSession()->getMapInfo().isGeocentric();
// first, go through the features and build the model cache. Apply the model matrix' scale
// factor to any AutoTransforms directly (cloning them as necessary)
std::map< std::pair<URI, float>, osg::ref_ptr<osg::Node> > uniqueModels;
//std::map< Feature*, osg::ref_ptr<osg::Node> > featureModels;
StringExpression uriEx = *symbol->url();
NumericExpression scaleEx = *symbol->scale();
for( FeatureList::const_iterator f = features.begin(); f != features.end(); ++f )
{
Feature* input = f->get();
// evaluate the marker URI expression:
StringExpression uriEx = *symbol->url();
URI markerURI( input->eval(uriEx, &context), uriEx.uriContext() );
// find the corresponding marker in the cache
MarkerResource* marker = 0L;
MarkerCache::Record rec = _markerCache.get( markerURI );
if ( rec.valid() ) {
marker = rec.value();
}
else {
marker = new MarkerResource();
marker->uri() = markerURI;
_markerCache.insert( markerURI, marker );
}
// evalute the scale expression (if there is one)
float scale = 1.0f;
osg::Matrixd scaleMatrix;
if ( symbol->scale().isSet() )
{
scale = input->eval( scaleEx, &context );
if ( scale == 0.0 )
scale = 1.0;
scaleMatrix = osg::Matrix::scale( scale, scale, scale );
}
// how that we have a marker source, create a node for it
std::pair<URI,float> key( markerURI, scale );
osg::ref_ptr<osg::Node>& model = uniqueModels[key];
if ( !model.valid() )
{
model = context.resourceCache()->getMarkerNode( marker );
if ( scale != 1.0f && dynamic_cast<osg::AutoTransform*>( model.get() ) )
{
// clone the old AutoTransform, set the new scale, and copy over its children.
osg::AutoTransform* oldAT = dynamic_cast<osg::AutoTransform*>(model.get());
osg::AutoTransform* newAT = osg::clone( oldAT );
// make a scaler and put it between the new AutoTransform and its kids
osg::MatrixTransform* scaler = new osg::MatrixTransform(osg::Matrix::scale(scale,scale,scale));
for( unsigned i=0; i<newAT->getNumChildren(); ++i )
scaler->addChild( newAT->getChild(0) );
newAT->removeChildren(0, newAT->getNumChildren());
newAT->addChild( scaler );
model = newAT;
}
}
if ( model.valid() )
{
GeometryIterator gi( input->getGeometry(), false );
while( gi.hasMore() )
{
Geometry* geom = gi.next();
for( unsigned i=0; i<geom->size(); ++i )
{
osg::Matrixd mat;
osg::Vec3d point = (*geom)[i];
if ( makeECEF )
{
// the "rotation" element lets us re-orient the instance to ensure it's pointing up. We
// could take a shortcut and just use the current extent's local2world matrix for this,
// but if the tile is big enough the up vectors won't be quite right.
osg::Matrixd rotation;
ECEF::transformAndGetRotationMatrix( point, context.profile()->getSRS(), point, rotation );
mat = rotation * scaleMatrix * osg::Matrixd::translate( point ) * _world2local;
}
else
{
mat = scaleMatrix * osg::Matrixd::translate( point ) * _world2local;
}
osg::MatrixTransform* xform = new osg::MatrixTransform();
xform->setMatrix( mat );
xform->addChild( model.get() );
attachPoint->addChild( xform );
// name the feature if necessary
if ( !_featureNameExpr.empty() )
{
const std::string& name = input->eval( _featureNameExpr, &context);
if ( !name.empty() )
xform->setName( name );
}
}
}
}
}
return true;
}
