/usr/include/osgTerrain/Locator is in libopenscenegraph-dev 3.0.1-4.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 | /* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 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_LOCATOR
#define OSGTERRAIN_LOCATOR 1
#include <osg/Object>
#include <osg/Vec3d>
#include <osg/CoordinateSystemNode>
#include <osgTerrain/Export>
namespace osgTerrain {
class OSGTERRAIN_EXPORT Locator : public osg::Object
{
public:
Locator();
/** Copy constructor using CopyOp to manage deep vs shallow copy.*/
Locator(const Locator&,const osg::CopyOp& copyop=osg::CopyOp::SHALLOW_COPY);
META_Object(osgTerrain, Locator);
/** 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 coordinate system i.e. UTMs.*/
PROJECTED
};
/** Set the CoordinatesSyetemType.
* Note, the user must keep the CoordinateSystemString consistent with the type of the CoordinateSystem.*/
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 transformation from local coordinates to model coordinates.*/
void setTransform(const osg::Matrixd& transform) { _transform = transform; _inverse.invert(_transform); }
/** Set the transformation from local coordinates to model coordinates.*/
const osg::Matrixd& getTransform() const { return _transform; }
/** Set the extents of the local coords.*/
void setTransformAsExtents(double minX, double minY, double maxX, double 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)
{
osg::Vec3d model;
if (!source.convertLocalToModel(sourceNDC, model)) return false;
if (!destination.convertModelToLocal(model, destinationNDC)) return false;
return true;
}
bool computeLocalBounds(Locator& source, osg::Vec3d& bottomLeft, osg::Vec3d& topRight) const;
void setDefinedInFile(bool flag) { _definedInFile = flag; }
bool getDefinedInFile() const { return _definedInFile; }
void setTransformScaledByResolution(bool scaledByResolution) { _transformScaledByResolution = scaledByResolution; }
bool getTransformScaledByResolution() const { return _transformScaledByResolution; }
protected:
virtual ~Locator();
CoordinateSystemType _coordinateSystemType;
std::string _format;
std::string _cs;
osg::ref_ptr<osg::EllipsoidModel> _ellipsoidModel;
osg::Matrixd _transform;
osg::Matrixd _inverse;
bool _definedInFile;
bool _transformScaledByResolution;
};
}
#endif
|