From 5b1b648ef5c67ce0eb7de0fc31f8ffa9f7907f19 Mon Sep 17 00:00:00 2001 From: Robert Osfield Date: Mon, 27 Aug 2007 16:59:51 +0000 Subject: [PATCH] Replaced CartesianLocator and EllipsoidLocator by a single general purpose Locator class --- examples/osgterrain/osgterrain.cpp | 12 +- include/osgTerrain/Locator | 149 ++++++------- src/osgPlugins/osgTerrain/Terrain.cpp | 165 ++++++++++++-- src/osgTerrain/Locator.cpp | 180 ++++++++-------- src/osgWrappers/osgTerrain/Locator.cpp | 288 +++++++++++-------------- 5 files changed, 449 insertions(+), 345 deletions(-) diff --git a/examples/osgterrain/osgterrain.cpp b/examples/osgterrain/osgterrain.cpp index 1d0d7bc39..6418b0d39 100644 --- a/examples/osgterrain/osgterrain.cpp +++ b/examples/osgterrain/osgterrain.cpp @@ -635,10 +635,13 @@ int main(int argc, char** argv) osg::ref_ptr terrain = new osgTerrain::Terrain; - osg::ref_ptr locator = new osgTerrain::EllipsoidLocator(-osg::PI, -osg::PI*0.5, 2.0*osg::PI, osg::PI, 0.0); + osg::ref_ptr locator = new osgTerrain::Locator; osg::ref_ptr validDataOperator = new osgTerrain::NoDataValue(0.0); osg::ref_ptr lastAppliedLayer; + locator->setCoordinateSystemType(osgTerrain::Locator::GEOCENTRIC); + locator->setExtents(-osg::PI, -osg::PI*0.5, osg::PI, osg::PI*0.5); + unsigned int layerNum = 0; std::string filterName; @@ -668,7 +671,8 @@ int main(int argc, char** argv) else if (arguments.read(pos, "-e",x,y,w,h)) { // define the extents. - locator = new osgTerrain::EllipsoidLocator(x,y,w,h,0); + locator->setCoordinateSystemType(osgTerrain::Locator::GEOCENTRIC); + locator->setExtents(x,y,x+w,y+h); readParameter = true; } @@ -681,8 +685,8 @@ int main(int argc, char** argv) else if (arguments.read(pos, "--cartesian",x,y,w,h)) { // define the extents. - locator = new osgTerrain::CartesianLocator(x,y,w,h,0); - readParameter = true; + locator->setCoordinateSystemType(osgTerrain::Locator::PROJECTED); + locator->setExtents(x,y,x+w,y+h); } else if (arguments.read(pos, "--hf",filename)) diff --git a/include/osgTerrain/Locator b/include/osgTerrain/Locator index 44a730bc1..bd578fb93 100644 --- a/include/osgTerrain/Locator +++ b/include/osgTerrain/Locator @@ -32,11 +32,75 @@ class OSGTERRAIN_EXPORT Locator : public osg::Object Locator(const Locator&,const osg::CopyOp& copyop=osg::CopyOp::SHALLOW_COPY); META_Object(osgTerrain, Locator); - - virtual bool orientationOpenGL() const { return true; } - virtual bool convertLocalToModel(const osg::Vec3d& /*local*/, osg::Vec3d& /*world*/) const { return false; } - virtual bool convertModelToLocal(const osg::Vec3d& /*world*/, osg::Vec3d& /*local*/) const { return false; } + /** CoordinateSystemType provides the classification of the type coordinate system represented.*/ + enum CoordinateSystemType + { + /** GEOCENTRIC coordinate systems are ones mapped to the around the ellipsoid, i.e. whole earth.*/ + GEOCENTRIC, + + /** GEOGRAPHIC coordinate systems are ones mapped to latitude and longitude.*/ + GEOGRAPHIC, + + /** PROJECTED coordinate systems are ones projected to a local projected coordindate system i.e. UTMs.*/ + PROJECTED + }; + + /** Set the CoordinatesSyetemType. + * Note, the user must keep the CoordinateSystemString consistent with the type of the CoordindateSystem.*/ + void setCoordinateSystemType(CoordinateSystemType type) { _coordinateSystemType = type; } + + /** Get the CoordinatesSyetemType.*/ + CoordinateSystemType getCoordinateSystemType() const { return _coordinateSystemType; } + + /** Set the coordinate system format string. Typical values would be WKT, PROJ4, USGS etc.*/ + void setFormat(const std::string& format) { _format = format; } + + /** Get the coordinate system format string.*/ + const std::string& getFormat() const { return _format; } + + /** Set the CoordinateSystem reference string, should be stored in a form consistent with the Format.*/ + void setCoordinateSystem(const std::string& cs) { _cs = cs; } + + /** Get the CoordinateSystem reference string.*/ + const std::string& getCoordinateSystem() const { return _cs; } + + + /** Set EllipsoidModel to describe the model used to map lat, long and height into geocentric XYZ and back. */ + void setEllipsoidModel(osg::EllipsoidModel* ellipsode) { _ellipsoidModel = ellipsode; } + + /** Get the EllipsoidModel.*/ + osg::EllipsoidModel* getEllipsoidModel() { return _ellipsoidModel.get(); } + + /** Get the const EllipsoidModel.*/ + const osg::EllipsoidModel* getEllipsoidModel() const { return _ellipsoidModel.get(); } + + + + /** Set the extents of the local coords.*/ + void setExtents(double minX, double minY, double maxX, double maxY); + + /** Get the extents of the local coords.*/ + void getExtents(double& minX, double& minY, double& maxX, double& maxY) const; + + void setMinX(double minX) { _minX = minX; } + double getMinX() const { return _minX; } + + void setMinY(double minY) { _minY = minY; } + double getMinY() const { return _minY; } + + void setMaxX(double maxX) { _maxX = maxX; } + double getMaxX() const { return _maxX; } + + void setMaxY(double maxY) { _maxY = maxY; } + double getMaxY() const { return _maxY; } + + + virtual bool orientationOpenGL() const; + + virtual bool convertLocalToModel(const osg::Vec3d& /*local*/, osg::Vec3d& /*world*/) const; + + virtual bool convertModelToLocal(const osg::Vec3d& /*world*/, osg::Vec3d& /*local*/) const; static bool convertLocalCoordBetween(const Locator& source, const osg::Vec3d& sourceNDC, const Locator& destination, osg::Vec3d& destinationNDC) @@ -53,78 +117,17 @@ class OSGTERRAIN_EXPORT Locator : public osg::Object virtual ~Locator(); -}; + CoordinateSystemType _coordinateSystemType; -class OSGTERRAIN_EXPORT EllipsoidLocator : public osgTerrain::Locator -{ - public: + std::string _format; + std::string _cs; + osg::ref_ptr _ellipsoidModel; + double _minX; + double _minY; + double _maxX; + double _maxY; - EllipsoidLocator(double longitude, double latitude, double deltaLongitude, double deltaLatitude, double height=0.0, double heightScale = 1.0f, double radiusEquator = osg::WGS_84_RADIUS_EQUATOR, double radiusPolar = osg::WGS_84_RADIUS_POLAR); - - void setExtents(double longitude, double latitude, double deltaLongitude, double deltaLatitude, double height=0.0, double heightScale = 1.0f); - - double getLongitude() const { return _longitude; } - double getDeltaLongitude() const { return _deltaLongitude; } - - double getLatitude() const { return _latitude; } - double getDeltaLatitude() const { return _deltaLatitude; } - - double getHeight() const { return _height; } - - void setEllipsoidModel(osg::EllipsoidModel* em) { _em=em; } - osg::EllipsoidModel* getEllipsoidModel() { return _em.get(); } - const osg::EllipsoidModel* getEllipsoidModel() const { return _em.get(); } - - virtual bool orientationOpenGL() const; - virtual bool convertLocalToModel(const osg::Vec3d& local, osg::Vec3d& world) const; - virtual bool convertModelToLocal(const osg::Vec3d& world, osg::Vec3d& local) const; - - protected: - - osg::ref_ptr _em; - - double _longitude; - double _latitude; - double _deltaLongitude; - double _deltaLatitude; - double _height; - double _heightScale; -}; - - -class OSGTERRAIN_EXPORT CartesianLocator : public osgTerrain::Locator -{ - public: - - CartesianLocator(double originX, double originY, double lengthX, double lengthY, double height = 0.0f, double heightScale = 1.0f); - - void setExtents(double originX, double originY, double lengthX, double lengthY, double height = 0.0f, double heightScale = 1.0f); - - void setOriginX(double x) { _originX = x; } - double getOriginX() const { return _originX; } - - void setOriginY(double y) { _originY = y; } - double getOriginY() const { return _originY; } - - void setLengthX(double x) { _lengthX = x; } - double getLengthX() const { return _lengthX; } - - void setLengthY(double y) { _lengthY = y; } - double getLengthY() const { return _lengthY; } - - virtual bool orientationOpenGL() const; - virtual bool convertLocalToModel(const osg::Vec3d& local, osg::Vec3d& world) const; - virtual bool convertModelToLocal(const osg::Vec3d& world, osg::Vec3d& local) const; - - protected: - - double _originX; - double _originY; - double _lengthX; - double _lengthY; - double _height; - double _heightScale; }; } diff --git a/src/osgPlugins/osgTerrain/Terrain.cpp b/src/osgPlugins/osgTerrain/Terrain.cpp index 217402f79..0cfeae1aa 100644 --- a/src/osgPlugins/osgTerrain/Terrain.cpp +++ b/src/osgPlugins/osgTerrain/Terrain.cpp @@ -114,6 +114,86 @@ osgTerrain::Layer* readLayer(osgDB::Input& fr) itrAdvanced = true; } + if (fr.matchSequence("Locator %w %f %f %f")) + { + + double x,y,w,h; + fr[2].getFloat(x); + fr[3].getFloat(y); + fr[4].getFloat(w); + fr[5].getFloat(h); + + locator = new osgTerrain::Locator; + + if (fr[1].matchWord("GEOCENTRIC")) locator->setCoordinateSystemType(osgTerrain::Locator::GEOCENTRIC); + else if (fr[1].matchWord("GEOGRAPHIC")) locator->setCoordinateSystemType(osgTerrain::Locator::GEOGRAPHIC); + else locator->setCoordinateSystemType(osgTerrain::Locator::PROJECTED); + locator->setExtents(x,y,x+w,y+h); + + fr += 6; + itrAdvanced = true; + } + + if (fr.matchSequence("Locator {")) + { + locator = new osgTerrain::Locator; + + int local_entry = fr[0].getNoNestedBrackets(); + + fr += 2; + while (!fr.eof() && fr[0].getNoNestedBrackets()>local_entry) + { + bool localAdvanced = false; + + if (fr.matchSequence("Format %w") || fr.matchSequence("Format %s") ) + { + locator->setFormat(fr[1].getStr()); + + fr += 2; + localAdvanced = true; + } + + if (fr.matchSequence("CoordinateSystemType %w")) + { + if (fr[1].matchWord("GEOCENTRIC")) locator->setCoordinateSystemType(osgTerrain::Locator::GEOCENTRIC); + else if (fr[1].matchWord("GEOGRAPHIC")) locator->setCoordinateSystemType(osgTerrain::Locator::GEOGRAPHIC); + else locator->setCoordinateSystemType(osgTerrain::Locator::PROJECTED); + + fr += 2; + localAdvanced = true; + } + + + if (fr.matchSequence("CoordinateSystem %w") || fr.matchSequence("CoordinateSystem %s") ) + { + locator->setCoordinateSystem(fr[1].getStr()); + + fr += 2; + localAdvanced = true; + } + + if (fr.matchSequence("Extents %f %f %f %f")) + { + double minX,minY,maxX,maxY; + fr[1].getFloat(minX); + fr[2].getFloat(minY); + fr[3].getFloat(maxX); + fr[4].getFloat(maxY); + + locator->setExtents(minX, minY, maxX, maxY); + + fr += 5; + localAdvanced = true; + } + + if (!localAdvanced) ++fr; + } + + itrAdvanced = true; + + ++fr; + } + if (fr.matchSequence("EllipsoidLocator %f %f %f %f")) { double x,y,w,h; @@ -122,7 +202,9 @@ osgTerrain::Layer* readLayer(osgDB::Input& fr) fr[3].getFloat(w); fr[4].getFloat(h); - locator = new osgTerrain::EllipsoidLocator(x,y,w,h,0); + locator = new osgTerrain::Locator; + locator->setCoordinateSystemType(osgTerrain::Locator::GEOCENTRIC); + locator->setExtents(x,y,x+w,y+h); fr += 5; itrAdvanced = true; @@ -136,8 +218,10 @@ osgTerrain::Layer* readLayer(osgDB::Input& fr) fr[3].getFloat(w); fr[4].getFloat(h); - locator = new osgTerrain::CartesianLocator(x,y,w,h,0); - + locator = new osgTerrain::Locator; + locator->setCoordinateSystemType(osgTerrain::Locator::PROJECTED); + locator->setExtents(x,y,x+w,y+h); + fr += 5; itrAdvanced = true; } @@ -313,30 +397,76 @@ bool Terrain_readLocalData(osg::Object& obj, osgDB::Input &fr) itrAdvanced = true; } +#if 1 if (!(terrain.getTerrainTechnique())) { terrain.setTerrainTechnique(new osgTerrain::GeometryTechnique); } - +#endif return itrAdvanced; } bool writeLocator(const osgTerrain::Locator& locator, osgDB::Output& fw) { - const osgTerrain::CartesianLocator* cartesian = dynamic_cast(&locator); - if (cartesian) - { - fw.indent()<<"CartesianLocator "<getOriginX()<<" "<getOriginY()<<" "<getLengthX()<<" "<getLengthY()<(&locator); - if (ellipsoid) - { - fw.indent()<<"CartesianLocator "<getLongitude()<<" "<getLatitude()<<" "<getDeltaLongitude()<<" "<getDeltaLatitude()<(obj); + int prec = fw.precision(); + fw.precision(15); + if (terrain.getLocator()) { writeLocator(*terrain.getLocator(),fw); @@ -434,5 +567,7 @@ bool Terrain_writeLocalData(const osg::Object& obj, osgDB::Output& fw) } } + fw.precision(prec); + return true; } diff --git a/src/osgTerrain/Locator.cpp b/src/osgTerrain/Locator.cpp index 07e0ebd66..20d300b0e 100644 --- a/src/osgTerrain/Locator.cpp +++ b/src/osgTerrain/Locator.cpp @@ -12,6 +12,7 @@ */ #include +#include #include @@ -21,12 +22,26 @@ using namespace osgTerrain; // // Locator // -Locator::Locator() +Locator::Locator(): + _coordinateSystemType(PROJECTED), + _ellipsoidModel(new osg::EllipsoidModel()), + _minX(0.0), + _minY(0.0), + _maxX(0.0), + _maxY(0.0) { } -Locator::Locator(const Locator& Locator,const osg::CopyOp& copyop): - osg::Object(Locator,copyop) +Locator::Locator(const Locator& locator,const osg::CopyOp& copyop): + osg::Object(locator,copyop), + _coordinateSystemType(locator._coordinateSystemType), + _ellipsoidModel(locator._ellipsoidModel), + _format(locator._format), + _cs(locator._cs), + _minX(locator._minX), + _minY(locator._minY), + _maxX(locator._maxX), + _maxY(locator._maxY) { } @@ -34,6 +49,14 @@ Locator::~Locator() { } +void Locator::setExtents(double minX, double minY, double maxX, double maxY) +{ + _minX = minX; + _minY = minY; + _maxX = maxX; + _maxY = maxY; +} + bool Locator::computeLocalBounds(Locator& source, osg::Vec3d& bottomLeft, osg::Vec3d& topRight) { typedef std::list Corners; @@ -76,96 +99,77 @@ bool Locator::computeLocalBounds(Locator& source, osg::Vec3d& bottomLeft, osg::V return true; } -////////////////////////////////////////////////////////////////////////////// -// -// EllipsoidLocator -// -EllipsoidLocator::EllipsoidLocator(double longitude, double latitude, double deltaLongitude, double deltaLatitude, double height, double heightScale, double radiusEquator, double radiusPolar) +bool Locator::orientationOpenGL() const { - setExtents(longitude, latitude, deltaLongitude, deltaLatitude, height, heightScale); - _em = new osg::EllipsoidModel(radiusEquator, radiusPolar); + return ((_maxX-_minX) * (_maxY-_minY)) >= 0.0; } -void EllipsoidLocator::setExtents(double longitude, double latitude, double deltaLongitude, double deltaLatitude, double height, double heightScale) +bool Locator::convertLocalToModel(const osg::Vec3d& local, osg::Vec3d& world) const { - _longitude = longitude; - _latitude = latitude; - _deltaLongitude = deltaLongitude; - _deltaLatitude = deltaLatitude; - _height = height; - _heightScale = heightScale; + switch(_coordinateSystemType) + { + case(GEOCENTRIC): + { + double longitude = _minX * (1.0-local.x()) + _maxX * local.x(); + double latitude = _minY * (1.0-local.y()) + _maxY * local.y(); + double height = local.z(); + + _ellipsoidModel->convertLatLongHeightToXYZ(latitude, longitude, height, + world.x(), world.y(), world.z()); + return true; + } + case(GEOGRAPHIC): + { + world.x() = _minX * (1.0-local.x()) + _maxX * local.x(); + world.y() = _minY * (1.0-local.y()) + _maxY * local.y(); + world.z() = local.z(); + return true; + } + case(PROJECTED): + { + world.x() = _minX * (1.0-local.x()) + _maxX * local.x(); + world.y() = _minY * (1.0-local.y()) + _maxY * local.y(); + world.z() = local.z(); + return true; + } + } + + return false; } -bool EllipsoidLocator::orientationOpenGL() const +bool Locator::convertModelToLocal(const osg::Vec3d& world, osg::Vec3d& local) const { - return (_deltaLongitude * _deltaLatitude) >= 0.0; -} - -bool EllipsoidLocator::convertLocalToModel(const osg::Vec3d& local, osg::Vec3d& world) const -{ - double longitude = _longitude + local.x() * _deltaLongitude; - double latitude = _latitude + local.y() * _deltaLatitude; - double height = _height + local.z() * _heightScale; - - _em->convertLatLongHeightToXYZ(latitude, longitude, height, - world.x(), world.y(), world.z()); - - return true; -} - -bool EllipsoidLocator::convertModelToLocal(const osg::Vec3d& world, osg::Vec3d& local) const -{ - double longitude, latitude, height; - - _em->convertXYZToLatLongHeight(world.x(), world.y(), world.z(), - latitude, longitude, height ); - - local.x() = (longitude-_longitude)/_deltaLongitude; - local.y() = (latitude-_latitude)/_deltaLatitude; - local.z() = (height-_height)/_heightScale; - - return true; -} - -////////////////////////////////////////////////////////////////////////////// -// -// CartesianLocator -// - -CartesianLocator::CartesianLocator(double originX, double originY, double lengthX, double lengthY, double height, double heightScale) -{ - setExtents(originX, originY, lengthX, lengthY, height, heightScale); -} - -void CartesianLocator::setExtents(double originX, double originY, double lengthX, double lengthY, double height, double heightScale) -{ - _originX = originX; - _originY = originY; - _lengthX = lengthX; - _lengthY = lengthY; - _height = height; - _heightScale = heightScale; -} - -bool CartesianLocator::orientationOpenGL() const -{ - return (_lengthX * _lengthY) >= 0.0; -} - -bool CartesianLocator::convertLocalToModel(const osg::Vec3d& local, osg::Vec3d& world) const -{ - world.x() = _originX + local.x() * _lengthX; - world.y() = _originY + local.y() * _lengthY; - world.z() = _height + local.z() * _heightScale; - - return true; -} - -bool CartesianLocator::convertModelToLocal(const osg::Vec3d& world, osg::Vec3d& local) const -{ - local.x() = (world.x() - _originX)/_lengthX; - local.y() = (world.y() - _originY)/_lengthY; - local.z() = (world.z() - _height)/_heightScale; - - return true; + switch(_coordinateSystemType) + { + case(GEOCENTRIC): + { + double longitude, latitude, height; + + _ellipsoidModel->convertXYZToLatLongHeight(world.x(), world.y(), world.z(), + latitude, longitude, height ); + + + local.x() = (longitude - _minX) / (_maxX - _minX); + local.y() = (latitude - _minY) / (_maxY - _minY); + local.z() = height; + + return true; + } + case(GEOGRAPHIC): + { + local.x() = (world.x() - _minX) / (_maxX - _minX); + local.y() = (world.y() - _minY) / (_maxY - _minY); + local.z() = world.z(); + return true; + } + case(PROJECTED): + { + local.x() = (world.x() - _minX) / (_maxX - _minX); + local.y() = (world.y() - _minY) / (_maxY - _minY); + local.z() = world.z(); + return true; + } + } + + return false; } diff --git a/src/osgWrappers/osgTerrain/Locator.cpp b/src/osgWrappers/osgTerrain/Locator.cpp index 69b6663b1..69a3a9407 100644 --- a/src/osgWrappers/osgTerrain/Locator.cpp +++ b/src/osgWrappers/osgTerrain/Locator.cpp @@ -24,172 +24,11 @@ #undef OUT #endif -BEGIN_OBJECT_REFLECTOR(osgTerrain::CartesianLocator) +BEGIN_ENUM_REFLECTOR(osgTerrain::Locator::CoordinateSystemType) I_DeclaringFile("osgTerrain/Locator"); - I_BaseType(osgTerrain::Locator); - I_ConstructorWithDefaults6(IN, double, originX, , IN, double, originY, , IN, double, lengthX, , IN, double, lengthY, , IN, double, height, 0.0f, IN, double, heightScale, 1.0f, - ____CartesianLocator__double__double__double__double__double__double, - "", - ""); - I_MethodWithDefaults6(void, setExtents, IN, double, originX, , IN, double, originY, , IN, double, lengthX, , IN, double, lengthY, , IN, double, height, 0.0f, IN, double, heightScale, 1.0f, - Properties::NON_VIRTUAL, - __void__setExtents__double__double__double__double__double__double, - "", - ""); - I_Method1(void, setOriginX, IN, double, x, - Properties::NON_VIRTUAL, - __void__setOriginX__double, - "", - ""); - I_Method0(double, getOriginX, - Properties::NON_VIRTUAL, - __double__getOriginX, - "", - ""); - I_Method1(void, setOriginY, IN, double, y, - Properties::NON_VIRTUAL, - __void__setOriginY__double, - "", - ""); - I_Method0(double, getOriginY, - Properties::NON_VIRTUAL, - __double__getOriginY, - "", - ""); - I_Method1(void, setLengthX, IN, double, x, - Properties::NON_VIRTUAL, - __void__setLengthX__double, - "", - ""); - I_Method0(double, getLengthX, - Properties::NON_VIRTUAL, - __double__getLengthX, - "", - ""); - I_Method1(void, setLengthY, IN, double, y, - Properties::NON_VIRTUAL, - __void__setLengthY__double, - "", - ""); - I_Method0(double, getLengthY, - Properties::NON_VIRTUAL, - __double__getLengthY, - "", - ""); - I_Method0(bool, orientationOpenGL, - Properties::VIRTUAL, - __bool__orientationOpenGL, - "", - ""); - I_Method2(bool, convertLocalToModel, IN, const osg::Vec3d &, local, IN, osg::Vec3d &, world, - Properties::VIRTUAL, - __bool__convertLocalToModel__C5_osg_Vec3d_R1__osg_Vec3d_R1, - "", - ""); - I_Method2(bool, convertModelToLocal, IN, const osg::Vec3d &, world, IN, osg::Vec3d &, local, - Properties::VIRTUAL, - __bool__convertModelToLocal__C5_osg_Vec3d_R1__osg_Vec3d_R1, - "", - ""); - I_SimpleProperty(double, LengthX, - __double__getLengthX, - __void__setLengthX__double); - I_SimpleProperty(double, LengthY, - __double__getLengthY, - __void__setLengthY__double); - I_SimpleProperty(double, OriginX, - __double__getOriginX, - __void__setOriginX__double); - I_SimpleProperty(double, OriginY, - __double__getOriginY, - __void__setOriginY__double); -END_REFLECTOR - -BEGIN_OBJECT_REFLECTOR(osgTerrain::EllipsoidLocator) - I_DeclaringFile("osgTerrain/Locator"); - I_BaseType(osgTerrain::Locator); - I_ConstructorWithDefaults8(IN, double, longitude, , IN, double, latitude, , IN, double, deltaLongitude, , IN, double, deltaLatitude, , IN, double, height, 0.0, IN, double, heightScale, 1.0f, IN, double, radiusEquator, osg::WGS_84_RADIUS_EQUATOR, IN, double, radiusPolar, osg::WGS_84_RADIUS_POLAR, - ____EllipsoidLocator__double__double__double__double__double__double__double__double, - "", - ""); - I_MethodWithDefaults6(void, setExtents, IN, double, longitude, , IN, double, latitude, , IN, double, deltaLongitude, , IN, double, deltaLatitude, , IN, double, height, 0.0, IN, double, heightScale, 1.0f, - Properties::NON_VIRTUAL, - __void__setExtents__double__double__double__double__double__double, - "", - ""); - I_Method0(double, getLongitude, - Properties::NON_VIRTUAL, - __double__getLongitude, - "", - ""); - I_Method0(double, getDeltaLongitude, - Properties::NON_VIRTUAL, - __double__getDeltaLongitude, - "", - ""); - I_Method0(double, getLatitude, - Properties::NON_VIRTUAL, - __double__getLatitude, - "", - ""); - I_Method0(double, getDeltaLatitude, - Properties::NON_VIRTUAL, - __double__getDeltaLatitude, - "", - ""); - I_Method0(double, getHeight, - Properties::NON_VIRTUAL, - __double__getHeight, - "", - ""); - I_Method1(void, setEllipsoidModel, IN, osg::EllipsoidModel *, em, - Properties::NON_VIRTUAL, - __void__setEllipsoidModel__osg_EllipsoidModel_P1, - "", - ""); - I_Method0(osg::EllipsoidModel *, getEllipsoidModel, - Properties::NON_VIRTUAL, - __osg_EllipsoidModel_P1__getEllipsoidModel, - "", - ""); - I_Method0(const osg::EllipsoidModel *, getEllipsoidModel, - Properties::NON_VIRTUAL, - __C5_osg_EllipsoidModel_P1__getEllipsoidModel, - "", - ""); - I_Method0(bool, orientationOpenGL, - Properties::VIRTUAL, - __bool__orientationOpenGL, - "", - ""); - I_Method2(bool, convertLocalToModel, IN, const osg::Vec3d &, local, IN, osg::Vec3d &, world, - Properties::VIRTUAL, - __bool__convertLocalToModel__C5_osg_Vec3d_R1__osg_Vec3d_R1, - "", - ""); - I_Method2(bool, convertModelToLocal, IN, const osg::Vec3d &, world, IN, osg::Vec3d &, local, - Properties::VIRTUAL, - __bool__convertModelToLocal__C5_osg_Vec3d_R1__osg_Vec3d_R1, - "", - ""); - I_SimpleProperty(double, DeltaLatitude, - __double__getDeltaLatitude, - 0); - I_SimpleProperty(double, DeltaLongitude, - __double__getDeltaLongitude, - 0); - I_SimpleProperty(osg::EllipsoidModel *, EllipsoidModel, - __osg_EllipsoidModel_P1__getEllipsoidModel, - __void__setEllipsoidModel__osg_EllipsoidModel_P1); - I_SimpleProperty(double, Height, - __double__getHeight, - 0); - I_SimpleProperty(double, Latitude, - __double__getLatitude, - 0); - I_SimpleProperty(double, Longitude, - __double__getLongitude, - 0); + I_EnumLabel(osgTerrain::Locator::GEOCENTRIC); + I_EnumLabel(osgTerrain::Locator::GEOGRAPHIC); + I_EnumLabel(osgTerrain::Locator::PROJECTED); END_REFLECTOR BEGIN_OBJECT_REFLECTOR(osgTerrain::Locator) @@ -227,6 +66,101 @@ BEGIN_OBJECT_REFLECTOR(osgTerrain::Locator) __C5_char_P1__className, "return the name of the object's class type. ", "Must be defined by derived classes. "); + I_Method1(void, setCoordinateSystemType, IN, osgTerrain::Locator::CoordinateSystemType, type, + Properties::NON_VIRTUAL, + __void__setCoordinateSystemType__CoordinateSystemType, + "Set the CoordinatesSyetemType. ", + "Note, the user must keep the CoordinateSystemString consistent with the type of the CoordindateSystem. "); + I_Method0(osgTerrain::Locator::CoordinateSystemType, getCoordinateSystemType, + Properties::NON_VIRTUAL, + __CoordinateSystemType__getCoordinateSystemType, + "Get the CoordinatesSyetemType. ", + ""); + I_Method1(void, setFormat, IN, const std::string &, format, + Properties::NON_VIRTUAL, + __void__setFormat__C5_std_string_R1, + "Set the coordinate system format string. ", + "Typical values would be WKT, PROJ4, USGS etc. "); + I_Method0(const std::string &, getFormat, + Properties::NON_VIRTUAL, + __C5_std_string_R1__getFormat, + "Get the coordinate system format string. ", + ""); + I_Method1(void, setCoordinateSystem, IN, const std::string &, cs, + Properties::NON_VIRTUAL, + __void__setCoordinateSystem__C5_std_string_R1, + "Set the CoordinateSystem reference string, should be stored in a form consistent with the Format. ", + ""); + I_Method0(const std::string &, getCoordinateSystem, + Properties::NON_VIRTUAL, + __C5_std_string_R1__getCoordinateSystem, + "Get the CoordinateSystem reference string. ", + ""); + I_Method1(void, setEllipsoidModel, IN, osg::EllipsoidModel *, ellipsode, + Properties::NON_VIRTUAL, + __void__setEllipsoidModel__osg_EllipsoidModel_P1, + "Set EllipsoidModel to describe the model used to map lat, long and height into geocentric XYZ and back. ", + ""); + I_Method0(osg::EllipsoidModel *, getEllipsoidModel, + Properties::NON_VIRTUAL, + __osg_EllipsoidModel_P1__getEllipsoidModel, + "Get the EllipsoidModel. ", + ""); + I_Method0(const osg::EllipsoidModel *, getEllipsoidModel, + Properties::NON_VIRTUAL, + __C5_osg_EllipsoidModel_P1__getEllipsoidModel, + "Get the const EllipsoidModel. ", + ""); + I_Method4(void, setExtents, IN, double, minX, IN, double, minY, IN, double, maxX, IN, double, maxY, + Properties::NON_VIRTUAL, + __void__setExtents__double__double__double__double, + "Set the extents of the local coords. ", + ""); + I_Method4(void, getExtents, IN, double &, minX, IN, double &, minY, IN, double &, maxX, IN, double &, maxY, + Properties::NON_VIRTUAL, + __void__getExtents__double_R1__double_R1__double_R1__double_R1, + "Get the extents of the local coords. ", + ""); + I_Method1(void, setMinX, IN, double, minX, + Properties::NON_VIRTUAL, + __void__setMinX__double, + "", + ""); + I_Method0(double, getMinX, + Properties::NON_VIRTUAL, + __double__getMinX, + "", + ""); + I_Method1(void, setMinY, IN, double, minY, + Properties::NON_VIRTUAL, + __void__setMinY__double, + "", + ""); + I_Method0(double, getMinY, + Properties::NON_VIRTUAL, + __double__getMinY, + "", + ""); + I_Method1(void, setMaxX, IN, double, maxX, + Properties::NON_VIRTUAL, + __void__setMaxX__double, + "", + ""); + I_Method0(double, getMaxX, + Properties::NON_VIRTUAL, + __double__getMaxX, + "", + ""); + I_Method1(void, setMaxY, IN, double, maxY, + Properties::NON_VIRTUAL, + __void__setMaxY__double, + "", + ""); + I_Method0(double, getMaxY, + Properties::NON_VIRTUAL, + __double__getMaxY, + "", + ""); I_Method0(bool, orientationOpenGL, Properties::VIRTUAL, __bool__orientationOpenGL, @@ -251,5 +185,29 @@ BEGIN_OBJECT_REFLECTOR(osgTerrain::Locator) __bool__convertLocalCoordBetween__C5_Locator_R1__C5_osg_Vec3d_R1__C5_Locator_R1__osg_Vec3d_R1_S, "", ""); + I_SimpleProperty(const std::string &, CoordinateSystem, + __C5_std_string_R1__getCoordinateSystem, + __void__setCoordinateSystem__C5_std_string_R1); + I_SimpleProperty(osgTerrain::Locator::CoordinateSystemType, CoordinateSystemType, + __CoordinateSystemType__getCoordinateSystemType, + __void__setCoordinateSystemType__CoordinateSystemType); + I_SimpleProperty(osg::EllipsoidModel *, EllipsoidModel, + __osg_EllipsoidModel_P1__getEllipsoidModel, + __void__setEllipsoidModel__osg_EllipsoidModel_P1); + I_SimpleProperty(const std::string &, Format, + __C5_std_string_R1__getFormat, + __void__setFormat__C5_std_string_R1); + I_SimpleProperty(double, MaxX, + __double__getMaxX, + __void__setMaxX__double); + I_SimpleProperty(double, MaxY, + __double__getMaxY, + __void__setMaxY__double); + I_SimpleProperty(double, MinX, + __double__getMinX, + __void__setMinX__double); + I_SimpleProperty(double, MinY, + __double__getMinY, + __void__setMinY__double); END_REFLECTOR