LargeScaleCoord::LargeScaleCoord(const osg::Vec3d& realCoord)
{
m_smallScale.set(0, 0, 0);
m_largeScale.set(realCoord.x() / sizeFactor, realCoord.y() / sizeFactor, realCoord.z() / sizeFactor);
}
bool
ElevationQuery::getElevationImpl(const osg::Vec3d& point,
const SpatialReference* pointSRS,
double& out_elevation,
double desiredResolution,
double* out_actualResolution)
{
if ( _maxDataLevel == 0 || _tileSize == 0 )
{
// this means there are no heightfields.
out_elevation = 0.0;
return true;
}
// this is the ideal LOD for the requested resolution:
unsigned int idealLevel = desiredResolution > 0.0
? _mapf.getProfile()->getLevelOfDetailForHorizResolution( desiredResolution, _tileSize )
: _maxDataLevel;
// based on the heightfields available, this is the best we can theorically do:
unsigned int bestAvailLevel = osg::minimum( idealLevel, _maxDataLevel );
if (_maxLevelOverride >= 0)
{
bestAvailLevel = osg::minimum(bestAvailLevel, (unsigned int)_maxLevelOverride);
}
// transform the input coords to map coords:
osg::Vec3d mapPoint = point;
if ( pointSRS && !pointSRS->isEquivalentTo( _mapf.getProfile()->getSRS() ) )
{
if ( !pointSRS->transform2D( point.x(), point.y(), _mapf.getProfile()->getSRS(), mapPoint.x(), mapPoint.y() ) )
{
OE_WARN << LC << "Fail: coord transform failed" << std::endl;
return false;
}
}
osg::ref_ptr<osg::HeightField> hf;
osg::ref_ptr<osgTerrain::TerrainTile> tile;
// get the tilekey corresponding to the tile we need:
TileKey key = _mapf.getProfile()->createTileKey( mapPoint.x(), mapPoint.y(), bestAvailLevel );
if ( !key.valid() )
{
OE_WARN << LC << "Fail: coords fall outside map" << std::endl;
return false;
}
// Check the tile cache. Note that the TileSource already likely has a MemCache
// attached to it. We employ a secondary cache here for a couple reasons. One, this
// cache will store not only the heightfield, but also the tesselated tile in the event
// that we're using GEOMETRIC mode. Second, since the call the getHeightField can
// fallback on a lower resolution, this cache will hold the final resolution heightfield
// instead of trying to fetch the higher resolution one each tiem.
TileCache::Record record = _tileCache.get( key );
if ( record.valid() )
tile = record.value().get();
// if we found it, make sure it has a heightfield in it:
if ( tile.valid() )
{
osgTerrain::HeightFieldLayer* layer = dynamic_cast<osgTerrain::HeightFieldLayer*>(tile->getElevationLayer());
if ( layer )
hf = layer->getHeightField();
if ( !hf.valid() )
tile = 0L;
}
// if we didn't find it (or it didn't have heightfield data), build it.
if ( !tile.valid() )
{
// generate the heightfield corresponding to the tile key, automatically falling back
// on lower resolution if necessary:
_mapf.getHeightField( key, true, hf, 0L, _interpolation );
// bail out if we could not make a heightfield a all.
if ( !hf.valid() )
{
OE_WARN << LC << "Unable to create heightfield for key " << key.str() << std::endl;
return false;
}
// All this stuff is requires for GEOMETRIC mode. An optimization would be to
// defer this so that PARAMETRIC mode doesn't waste time
GeoLocator* locator = GeoLocator::createForKey( key, _mapf.getMapInfo() );
tile = new osgTerrain::TerrainTile();
osgTerrain::HeightFieldLayer* layer = new osgTerrain::HeightFieldLayer( hf.get() );
layer->setLocator( locator );
tile->setElevationLayer( layer );
tile->setRequiresNormals( false );
tile->setTerrainTechnique( new osgTerrain::GeometryTechnique );
// store it in the local tile cache.
_tileCache.insert( key, tile.get() );
}
OE_DEBUG << LC << "LRU Cache, hit ratio = " << _tileCache.getStats()._hitRatio << std::endl;
// see what the actual resolution of the heightfield is.
if ( out_actualResolution )
*out_actualResolution = (double)hf->getXInterval();
// finally it's time to get a height value:
if ( _technique == TECHNIQUE_PARAMETRIC )
{
const GeoExtent& extent = key.getExtent();
double xInterval = extent.width() / (double)(hf->getNumColumns()-1);
double yInterval = extent.height() / (double)(hf->getNumRows()-1);
out_elevation = (double) HeightFieldUtils::getHeightAtLocation(
hf.get(), mapPoint.x(), mapPoint.y(), extent.xMin(), extent.yMin(), xInterval, yInterval );
return true;
}
else // ( _technique == TECHNIQUE_GEOMETRIC )
{
osg::Vec3d start, end, zero;
if ( _mapf.getMapInfo().isGeocentric() )
{
const SpatialReference* mapSRS = _mapf.getProfile()->getSRS();
mapSRS->transformToECEF( osg::Vec3d(mapPoint.y(), mapPoint.x(), 50000.0), start );
mapSRS->transformToECEF( osg::Vec3d(mapPoint.y(), mapPoint.x(), -50000.0), end );
mapSRS->transformToECEF( osg::Vec3d(mapPoint.y(), mapPoint.x(), 0.0), zero );
}
else // PROJECTED
{
start.set( mapPoint.x(), mapPoint.y(), 50000.0 );
end.set ( mapPoint.x(), mapPoint.y(), -50000.0 );
zero.set ( mapPoint.x(), mapPoint.y(), 0.0 );
}
osgUtil::LineSegmentIntersector* i = new osgUtil::LineSegmentIntersector( start, end );
osgUtil::IntersectionVisitor iv;
iv.setIntersector( i );
tile->accept( iv );
osgUtil::LineSegmentIntersector::Intersections& results = i->getIntersections();
if ( !results.empty() )
{
const osgUtil::LineSegmentIntersector::Intersection& result = *results.begin();
osg::Vec3d isectPoint = result.getWorldIntersectPoint();
out_elevation = (isectPoint-end).length2() > (zero-end).length2()
? (isectPoint-zero).length()
: -(isectPoint-zero).length();
return true;
}
OE_DEBUG << LC << "No intersection" << std::endl;
return false;
}
}
bool LineSegmentIntersector::intersectAndClip(osg::Vec3d& s, osg::Vec3d& e,const osg::BoundingBox& bbInput)
{
osg::Vec3d bb_min(bbInput._min);
osg::Vec3d bb_max(bbInput._max);
#if 1
double epsilon = 1e-4;
bb_min.x() -= epsilon;
bb_min.y() -= epsilon;
bb_min.z() -= epsilon;
bb_max.x() += epsilon;
bb_max.y() += epsilon;
bb_max.z() += epsilon;
#endif
// compate s and e against the xMin to xMax range of bb.
if (s.x()<=e.x())
{
// trivial reject of segment wholely outside.
if (e.x()<bb_min.x()) return false;
if (s.x()>bb_max.x()) return false;
if (s.x()<bb_min.x())
{
// clip s to xMin.
s = s+(e-s)*(bb_min.x()-s.x())/(e.x()-s.x());
}
if (e.x()>bb_max.x())
{
// clip e to xMax.
e = s+(e-s)*(bb_max.x()-s.x())/(e.x()-s.x());
}
}
else
{
if (s.x()<bb_min.x()) return false;
if (e.x()>bb_max.x()) return false;
if (e.x()<bb_min.x())
{
// clip s to xMin.
e = s+(e-s)*(bb_min.x()-s.x())/(e.x()-s.x());
}
if (s.x()>bb_max.x())
{
// clip e to xMax.
s = s+(e-s)*(bb_max.x()-s.x())/(e.x()-s.x());
}
}
// compate s and e against the yMin to yMax range of bb.
if (s.y()<=e.y())
{
// trivial reject of segment wholely outside.
if (e.y()<bb_min.y()) return false;
if (s.y()>bb_max.y()) return false;
if (s.y()<bb_min.y())
{
// clip s to yMin.
s = s+(e-s)*(bb_min.y()-s.y())/(e.y()-s.y());
}
if (e.y()>bb_max.y())
{
// clip e to yMax.
e = s+(e-s)*(bb_max.y()-s.y())/(e.y()-s.y());
}
}
else
{
if (s.y()<bb_min.y()) return false;
if (e.y()>bb_max.y()) return false;
if (e.y()<bb_min.y())
{
// clip s to yMin.
e = s+(e-s)*(bb_min.y()-s.y())/(e.y()-s.y());
}
if (s.y()>bb_max.y())
{
// clip e to yMax.
s = s+(e-s)*(bb_max.y()-s.y())/(e.y()-s.y());
}
}
// compate s and e against the zMin to zMax range of bb.
if (s.z()<=e.z())
{
// trivial reject of segment wholely outside.
if (e.z()<bb_min.z()) return false;
if (s.z()>bb_max.z()) return false;
if (s.z()<bb_min.z())
{
// clip s to zMin.
s = s+(e-s)*(bb_min.z()-s.z())/(e.z()-s.z());
}
if (e.z()>bb_max.z())
{
// clip e to zMax.
e = s+(e-s)*(bb_max.z()-s.z())/(e.z()-s.z());
}
}
else
{
if (s.z()<bb_min.z()) return false;
if (e.z()>bb_max.z()) return false;
if (e.z()<bb_min.z())
{
// clip s to zMin.
e = s+(e-s)*(bb_min.z()-s.z())/(e.z()-s.z());
}
if (s.z()>bb_max.z())
{
// clip e to zMax.
s = s+(e-s)*(bb_max.z()-s.z())/(e.z()-s.z());
}
}
// osg::notify(osg::NOTICE)<<"clampped segment "<<s<<" "<<e<<std::endl;
// if (s==e) return false;
return true;
}
bool Locator::computeLocalBounds(Locator& source, osg::Vec3d& bottomLeft, osg::Vec3d& topRight) const
{
typedef std::list<osg::Vec3d> Corners;
Corners corners;
osg::Vec3d cornerNDC;
if (convertLocalToModel(osg::Vec3d(0.0,0.0,0.0), cornerNDC))
{
corners.push_back(cornerNDC);
}
if (convertLocalToModel(osg::Vec3d(1.0,0.0,0.0), cornerNDC))
{
corners.push_back(cornerNDC);
}
if (convertLocalToModel(osg::Vec3d(0.0,1.0,0.0), cornerNDC))
{
corners.push_back(cornerNDC);
}
if (convertLocalToModel(osg::Vec3d(1.0,1.0,0.0), cornerNDC))
{
corners.push_back(cornerNDC);
}
if (convertLocalToModel(osg::Vec3d(0.0,0.0,1.0), cornerNDC))
{
corners.push_back(cornerNDC);
}
if (convertLocalToModel(osg::Vec3d(1.0,0.0,1.0), cornerNDC))
{
corners.push_back(cornerNDC);
}
if (convertLocalToModel(osg::Vec3d(0.0,1.0,1.0), cornerNDC))
{
corners.push_back(cornerNDC);
}
if (convertLocalToModel(osg::Vec3d(1.0,1.0,1.0), cornerNDC))
{
corners.push_back(cornerNDC);
}
if (corners.empty()) return false;
for(Corners::iterator itr = corners.begin();
itr != corners.end();
++itr)
{
bottomLeft.x() = osg::minimum( bottomLeft.x(), itr->x());
bottomLeft.y() = osg::minimum( bottomLeft.y(), itr->y());
bottomLeft.z() = osg::minimum( bottomLeft.z(), itr->z());
topRight.x() = osg::maximum( topRight.x(), itr->x());
topRight.y() = osg::maximum( topRight.y(), itr->y());
topRight.z() = osg::maximum( topRight.z(), itr->z());
}
return true;
}
bool
MercatorLocator::convertModelToLocal(const osg::Vec3d& world, osg::Vec3d& local) const
{
bool result = false;
// required becasue of an OSG bug
if ( !_inverseCalculated )
{
const_cast<MercatorLocator*>(this)->_inverse.invert( _transform );
const_cast<MercatorLocator*>(this)->_inverseCalculated = true;
}
switch(_coordinateSystemType)
{
case(GEOCENTRIC):
{
double longitude, latitude, height;
_ellipsoidModel->convertXYZToLatLongHeight(world.x(), world.y(), world.z(),
latitude, longitude, height );
local = osg::Vec3d(longitude, latitude, height) * _inverse;
double lon_deg = osg::RadiansToDegrees(longitude);
double lat_deg = osg::RadiansToDegrees(latitude);
double xr, yr;
getUV( _geoDataExtent, lon_deg, lat_deg, xr, yr );
local.x() = xr;
local.y() = 1.0-yr;
result = true;
}
break;
case(GEOGRAPHIC):
{
local = world * _inverse;
osg::Vec3d w = world;
double lon_deg = w.x();
double lat_deg = w.y();
double xr, yr;
getUV( _geoDataExtent, lon_deg, lat_deg, xr, yr );
local.x() = xr;
local.y() = 1.0-yr;
result = true;
}
break;
case(PROJECTED):
{
local = world * _inverse;
result = true;
}
break;
}
return result;
}
