Locator.h

Go to the documentation of this file.

/* -*-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();

        Locator(const Locator&,const osg::CopyOp& copyop=osg::CopyOp::SHALLOW_COPY);

        META_Object(osgTerrain, Locator);

        enum CoordinateSystemType
        {
            GEOCENTRIC,

            GEOGRAPHIC,

            PROJECTED
        };

        void setCoordinateSystemType(CoordinateSystemType type) { _coordinateSystemType = type; }

        CoordinateSystemType getCoordinateSystemType() const { return _coordinateSystemType; }

        void setFormat(const std::string& format) { _format = format; }

        const std::string& getFormat() const { return _format; }

        void setCoordinateSystem(const std::string& cs) { _cs = cs; }

        const std::string& getCoordinateSystem() const { return _cs; }


        void setEllipsoidModel(osg::EllipsoidModel* ellipsode) { _ellipsoidModel = ellipsode; }

        osg::EllipsoidModel* getEllipsoidModel() { return _ellipsoidModel.get(); }

        const osg::EllipsoidModel* getEllipsoidModel() const { return _ellipsoidModel.get(); }


        void setTransform(const osg::Matrixd& transform) { _transform = transform; _inverse.invert(_transform); }

        const osg::Matrixd& getTransform() const { return _transform; }

        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