FGFS-4.1/OpenSceneGraph
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Added Support for cluster culling.

Browse Source 
Removed osgTerrain::CoordinateSystem which is now replaced by
osg::CoordinateSystemNode.
This commit is contained in:
Robert Osfield
2004-04-29 22:22:22 +00:00
parent 5d79eb1c9d
commit 0ba2d26b1a
6 changed files with 129 additions and 343 deletions
Download Patch File Download Diff File Expand all files Collapse all files

210
include/osgTerrain/CoordinateSystem
View File

@@ -1,210 +0,0 @@
/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2003 Robert Osfield
*
* This library is open source and may be redistributed and/or modified under
* the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
* (at your option) any later version. The full license is in LICENSE file
* included with this distribution, and on the openscenegraph.org website.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* OpenSceneGraph Public License for more details.
*/
#ifndef OSGTERRAIN_COORDINATESYSTEM
#define OSGTERRAIN_COORDINATESYSTEM 1
#include <osg/Object>
#include <osg/Vec2>
#include <osg/Vec3>
#include <osg/Matrixd>
#include <osgTerrain/Export>
namespace osgTerrain
{
const double WGS_84_RADIUS_EQUATOR = 6378137.0;
const double WGS_84_RADIUS_POLAR = 6356752.3142;
class EllipsodeTransform
{
public:
EllipsodeTransform(double radiusEquator = WGS_84_RADIUS_EQUATOR,
double radiusPolar = WGS_84_RADIUS_POLAR):
_radiusEquator(radiusEquator),
_radiusPolar(radiusPolar) { computeCoefficients(); }
EllipsodeTransform(const EllipsodeTransform& et):
_radiusEquator(et._radiusEquator),
_radiusPolar(et._radiusPolar) { computeCoefficients(); }
void setRadiusEquator(double radius) { _radiusEquator = radius; computeCoefficients(); }
double getRadiusEquator() const { return _radiusEquator; }
void setRadiusPolar(double radius) { _radiusPolar = radius; computeCoefficients(); }
double getRadiusPolar() const { return _radiusPolar; }
inline void convertLatLongHeightToXYZ(double latitude, double longitude, double height,
double& X, double& Y, double& Z) const
{
// for details on maths see http://www.colorado.edu/geography/gcraft/notes/datum/gif/llhxyz.gif
double sin_latitude = sin(latitude);
double cos_latitude = cos(latitude);
double N = _radiusEquator / sqrt( 1.0 - _eccentricitySquared*sin_latitude*sin_latitude);
X = (N+height)*cos_latitude*cos(longitude);
Y = (N+height)*cos_latitude*sin(longitude);
Z = (N*(1-_eccentricitySquared)+height)*sin(latitude);
}
inline void convertXYZToLatLongHeight(double X, double Y, double Z,
double& latitude, double& longitude, double& height) const
{
// http://www.colorado.edu/geography/gcraft/notes/datum/gif/xyzllh.gif
double p = sqrt(X*X + Y*Y);
double theta = atan(Z*_radiusEquator/ (p*_radiusPolar));
double eDashSquared = (_radiusEquator*_radiusEquator - _radiusPolar*_radiusPolar)/
(_radiusPolar*_radiusPolar);
double sin_theta = sin(theta);
double cos_theta = cos(theta);
latitude = atan( (Z + eDashSquared*_radiusPolar*sin_theta*sin_theta*sin_theta) /
(p - _eccentricitySquared*_radiusEquator*cos_theta*cos_theta*cos_theta) );
longitude = atan2(Y,X);
double sin_latitude = sin(latitude);
double N = _radiusEquator / sqrt( 1.0 - _eccentricitySquared*sin_latitude*sin_latitude);
height = p/cos(latitude) - N;
}
inline void computeLocalToWorldTransform(double latitude, double longitude, double height, osg::Matrixd& localToWorld) const
{
double X, Y, Z;
convertLatLongHeightToXYZ(latitude,longitude,height,X,Y,Z);
localToWorld.makeTranslate(X,Y,Z);
// normalize X,Y,Z
double inverse_length = 1.0/sqrt(X*X + Y*Y + Z*Z);
X *= inverse_length;
Y *= inverse_length;
Z *= inverse_length;
double length_XY = sqrt(X*X + Y*Y);
double inverse_length_XY = 1.0/length_XY;
// Vx = |(-Y,X,0)|
localToWorld(0,0) = -Y*inverse_length_XY;
localToWorld(0,1) = X*inverse_length_XY;
localToWorld(0,2) = 0.0;
// Vy = /(-Z*X/(sqrt(X*X+Y*Y), -Z*Y/(sqrt(X*X+Y*Y),sqrt(X*X+Y*Y))|
double Vy_x = -Z*X*inverse_length_XY;
double Vy_y = -Z*Y*inverse_length_XY;
double Vy_z = length_XY;
inverse_length = 1.0/sqrt(Vy_x*Vy_x + Vy_y*Vy_y + Vy_z*Vy_z);
localToWorld(1,0) = Vy_x*inverse_length;
localToWorld(1,1) = Vy_y*inverse_length;
localToWorld(1,2) = Vy_z*inverse_length;
// Vz = (X,Y,Z)
localToWorld(2,0) = X;
localToWorld(2,1) = Y;
localToWorld(2,2) = Z;
}
osg::Vec3 computeGavitationVector(double X, double Y, double Z) const
{
osg::Vec3 normal(-X,-Y,-Z);
normal.normalize();
return normal;
}
protected:
void computeCoefficients()
{
double flattening = (_radiusEquator-_radiusPolar)/_radiusEquator;
_eccentricitySquared = 2*flattening - flattening*flattening;
}
double _radiusEquator;
double _radiusPolar;
double _eccentricitySquared;
};
/** CoordinateSystem encapsulate the coordinate system that associated with objects in a scene.*/
class CoordinateSystem : public osg::Object
{
public:
CoordinateSystem();
CoordinateSystem(const std::string& WTK);
/** Copy constructor using CopyOp to manage deep vs shallow copy.*/
CoordinateSystem(const CoordinateSystem&,const osg::CopyOp& copyop=osg::CopyOp::SHALLOW_COPY);
META_Object(osgTerrain,CoordinateSystem);
inline bool operator == (const CoordinateSystem& cs) const
{
if (this == &cs) return true;
if (_WKT != cs._WKT) return false;
return true;
}
inline bool operator != (const CoordinateSystem& cs) const
{
return !(*this==cs);
}
/** Set the CoordinateSystem reference string, should be stored in OpenGIS Well Know Text form.*/
void setWKT(const std::string& WKT) { _WKT = WKT; }
/** Get the CoordinateSystem reference string.*/
const std::string& getWKT() const { return _WKT; }
/** CoordinateTransformation is a helper class for transforming between two different CoodinateSystems.
* To use, simply constructor a CoordinateSystem::CoordinateTransformation convertor(sourceCS,destinateCS)
* and then convert indiviual points via v_destination = convert(v_source), or the
* CoordinateTransformation.convert(ptr,num) method when handling arrays of Vec2/Vec3's.*/
class CoordinateTransformation : public osg::Referenced
{
public:
static CoordinateTransformation* createCoordinateTransformation(const CoordinateSystem& source, const CoordinateSystem& destination);
static void setCoordinateTransformationPrototpe(CoordinateTransformation* ct);
virtual osg::Vec2 operator () (const osg::Vec2& source) const = 0;
virtual osg::Vec3 operator () (const osg::Vec3& source) const = 0;
virtual bool transform(unsigned int numPoints, osg::Vec2* vec2ptr) const = 0;
virtual bool transform(unsigned int numPoints, osg::Vec3* vec3ptr) const = 0;
protected:
CoordinateTransformation() {}
virtual ~CoordinateTransformation() {}
virtual CoordinateTransformation* cloneCoordinateTransformation(const CoordinateSystem& source, const CoordinateSystem& destination) const = 0;
};
protected:
virtual ~CoordinateSystem() {}
std::string _WKT;
};
}
#endif

51
include/osgTerrain/DataSet
View File

@@ -19,8 +19,7 @@
#include <osg/BoundingBox>
#include <osg/Image>
#include <osg/Shape>
#include <osgTerrain/CoordinateSystem>
#include <osg/CoordinateSystemNode>
#include <set>
@@ -53,7 +52,7 @@ class OSGTERRAIN_EXPORT DataSet : public osg::Referenced
_numValuesY(sp._numValuesY),
_numValuesZ(sp._numValuesZ) {}
SpatialProperties(osgTerrain::CoordinateSystem* cs, const osg::BoundingBox& extents):
SpatialProperties(osg::CoordinateSystemNode* cs, const osg::BoundingBox& extents):
_cs(cs),
_extents(extents),
_numValuesX(0),
@@ -81,7 +80,7 @@ class OSGTERRAIN_EXPORT DataSet : public osg::Referenced
_extents.expandBy( osg::Vec3(_numValuesX,_numValuesY,0.0)*_geoTransform);
}
osg::ref_ptr<osgTerrain::CoordinateSystem> _cs;
osg::ref_ptr<osg::CoordinateSystemNode> _cs;
osg::Matrixd _geoTransform;
osg::BoundingBox _extents;
unsigned int _numValuesX;
@@ -123,9 +122,9 @@ class OSGTERRAIN_EXPORT DataSet : public osg::Referenced
static SourceData* readData(Source* source);
osg::BoundingBox getExtents(const osgTerrain::CoordinateSystem* cs) const;
osg::BoundingBox getExtents(const osg::CoordinateSystemNode* cs) const;
const SpatialProperties& computeSpatialProperties(const osgTerrain::CoordinateSystem* cs) const;
const SpatialProperties& computeSpatialProperties(const osg::CoordinateSystemNode* cs) const;
bool intersects(const SpatialProperties& sp) const;
@@ -142,7 +141,7 @@ class OSGTERRAIN_EXPORT DataSet : public osg::Referenced
osg::ref_ptr<osg::Node> _model;
GDALDataset* _gdalDataSet;
typedef std::map<const osgTerrain::CoordinateSystem*,SpatialProperties> SpatialPropertiesMap;
typedef std::map<const osg::CoordinateSystemNode*,SpatialProperties> SpatialPropertiesMap;
mutable SpatialPropertiesMap _spatialPropertiesMap;
@@ -201,9 +200,9 @@ class OSGTERRAIN_EXPORT DataSet : public osg::Referenced
void setCoordinateSystemPolicy(ParameterPolicy policy) { _coordinateSystemPolicy = policy; }
ParameterPolicy getCoordinateSystemPolicy() const { return _coordinateSystemPolicy; }
void setCoordinateSystem(const std::string& wellKnownText) { _cs = new osgTerrain::CoordinateSystem(wellKnownText); }
void setCoordinateSystem(osgTerrain::CoordinateSystem* cs) { _cs = cs; }
osgTerrain::CoordinateSystem* getCoordinateSystem() { return _cs.get(); }
void setCoordinateSystem(const std::string& wellKnownText) { _cs = new osg::CoordinateSystemNode(wellKnownText); }
void setCoordinateSystem(osg::CoordinateSystemNode* cs) { _cs = cs; }
osg::CoordinateSystemNode* getCoordinateSystem() { return _cs.get(); }
void setGeoTransformPolicy(ParameterPolicy policy) { _geoTransformPolicy = policy; }
@@ -225,11 +224,11 @@ class OSGTERRAIN_EXPORT DataSet : public osg::Referenced
void loadSourceData();
bool needReproject(const osgTerrain::CoordinateSystem* cs) const;
bool needReproject(const osg::CoordinateSystemNode* cs) const;
bool needReproject(const osgTerrain::CoordinateSystem* cs, double minResolution, double maxResolution) const;
bool needReproject(const osg::CoordinateSystemNode* cs, double minResolution, double maxResolution) const;
Source* doReproject(const std::string& filename, osgTerrain::CoordinateSystem* cs, double targetResolution=0.0) const;
Source* doReproject(const std::string& filename, osg::CoordinateSystemNode* cs, double targetResolution=0.0) const;
void buildOverviews();
@@ -745,7 +744,7 @@ class OSGTERRAIN_EXPORT DataSet : public osg::Referenced
_maxVisibleDistance(FLT_MAX),
_subTileGenerated(false) {}
CompositeDestination(osgTerrain::CoordinateSystem* cs, const osg::BoundingBox& extents):
CompositeDestination(osg::CoordinateSystemNode* cs, const osg::BoundingBox& extents):
SpatialProperties(cs,extents),
_dataSet(0),
_parent(0),
@@ -851,19 +850,19 @@ class OSGTERRAIN_EXPORT DataSet : public osg::Referenced
void setDefaultColor(const osg::Vec4& defaultColor) { _defaultColor = defaultColor; }
const osg::Vec4& getDefaultColor() const { return _defaultColor; }
void setDestinationCoordinateSystem(const std::string& wellKnownText) { setDestinationCoordinateSystem(new osgTerrain::CoordinateSystem(wellKnownText)); }
void setDestinationCoordinateSystem(osgTerrain::CoordinateSystem* cs) { _destinationCoordinateSystem = cs; }
osgTerrain::CoordinateSystem* getDestinationCoordinateSystem() { return _destinationCoordinateSystem .get(); }
void setDestinationCoordinateSystem(const std::string& wellKnownText) { setDestinationCoordinateSystem(new osg::CoordinateSystemNode(wellKnownText)); }
void setDestinationCoordinateSystem(osg::CoordinateSystemNode* cs) { _destinationCoordinateSystem = cs; }
osg::CoordinateSystemNode* getDestinationCoordinateSystem() { return _destinationCoordinateSystem .get(); }
void setIntermediateCoordinateSystem(const std::string& wellKnownText) { setIntermediateCoordinateSystem(new osgTerrain::CoordinateSystem(wellKnownText)); }
void setIntermediateCoordinateSystem(osgTerrain::CoordinateSystem* cs) { _intermediateCoordinateSystem = cs; }
osgTerrain::CoordinateSystem* getIntermediateCoordinateSystem() { return _intermediateCoordinateSystem.get(); }
void setIntermediateCoordinateSystem(const std::string& wellKnownText) { setIntermediateCoordinateSystem(new osg::CoordinateSystemNode(wellKnownText)); }
void setIntermediateCoordinateSystem(osg::CoordinateSystemNode* cs) { _intermediateCoordinateSystem = cs; }
osg::CoordinateSystemNode* getIntermediateCoordinateSystem() { return _intermediateCoordinateSystem.get(); }
void setConvertFromGeographicToGeocentric(bool flag) { _convertFromGeographicToGeocentric = flag; }
bool getConvertFromGeographicToGeocentric() const { return _convertFromGeographicToGeocentric; }
void setEllipsodeTransform(const osgTerrain::EllipsodeTransform& et) { _ellipsodeTransform = et; }
osgTerrain::EllipsodeTransform& getEllipsodeTransform() { return _ellipsodeTransform; }
void setEllipsoidModel(osg::EllipsoidModel* et) { _ellipsoidModel = et; }
osg::EllipsoidModel* getEllipsoidModel() { return _ellipsoidModel.get(); }
void setDestinationExtents(const osg::BoundingBox& extents) { _extents = extents; }
@@ -907,7 +906,7 @@ class OSGTERRAIN_EXPORT DataSet : public osg::Referenced
CompositeDestination* createDestinationGraph(CompositeDestination* parent,
osgTerrain::CoordinateSystem* cs,
osg::CoordinateSystemNode* cs,
const osg::BoundingBox& extents,
unsigned int maxImageSize,
unsigned int maxTerrainSize,
@@ -950,11 +949,11 @@ class OSGTERRAIN_EXPORT DataSet : public osg::Referenced
float _radiusToMaxVisibleDistanceRatio;
float _verticalScale;
osg::ref_ptr<osgTerrain::CoordinateSystem> _destinationCoordinateSystem;
osg::ref_ptr<osgTerrain::CoordinateSystem> _intermediateCoordinateSystem;
osg::ref_ptr<osg::CoordinateSystemNode> _destinationCoordinateSystem;
osg::ref_ptr<osg::CoordinateSystemNode> _intermediateCoordinateSystem;
bool _convertFromGeographicToGeocentric;
osgTerrain::EllipsodeTransform _ellipsodeTransform;
osg::ref_ptr<osg::EllipsoidModel> _ellipsoidModel;
osg::Matrixd _geoTransform;
osg::BoundingBox _extents;

13
include/osgTerrain/Terrain
View File

@@ -18,7 +18,7 @@
#include <osg/Image>
#include <osgTerrain/Renderer>
#include <osgTerrain/CoordinateSystem>
#include <osg/CoordinateSystemNode>
namespace osgTerrain {
@@ -38,16 +38,6 @@ class OSGTERRAIN_EXPORT Terrain : public osg::Group
virtual void traverse(osg::NodeVisitor& nv);
/** Set the coordinates system associated with this Terrain*/
void setCoordinateSystem(CoordinateSystem* cs) { _coordinateSystem = cs; }
/** Get the coordinates system associated with this Terrain*/
CoordinateSystem* getCoordinateSystem() { return _coordinateSystem.get(); }
/** Get the const coordinates system associated with this Terrain*/
const CoordinateSystem* getCoordinateSystem() const { return _coordinateSystem.get(); }
/** Set the HeightField for this Terrain.
* If a Renderer is attached then this will be notified.*/
void setHeightField(osg::HeightField* heightField);
@@ -96,7 +86,6 @@ class OSGTERRAIN_EXPORT Terrain : public osg::Group
virtual ~Terrain();
osg::ref_ptr<CoordinateSystem> _coordinateSystem;
osg::ref_ptr<osg::HeightField> _heightField;
osg::ref_ptr<Renderer> _renderer;