/home/cube/sources/osgearth/src/osgEarth/SpatialReference

Go to the documentation of this file.

/* -*-c++-*- */
/* osgEarth - Dynamic map generation toolkit for OpenSceneGraph
 * Copyright 2008-2010 Pelican Mapping
 * http://osgearth.org
 *
 * osgEarth is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program 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
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>
 */
#ifndef OSGEARTH_SPATIAL_REFERENCE_H
#define OSGEARTH_SPATIAL_REFERENCE_H 1

#include <osgEarth/Common>
#include <osgEarth/Units>
#include <osg/Referenced>
#include <osg/CoordinateSystemNode>
#include <osg/Vec3>
#include <OpenThreads/ReentrantMutex>

namespace osgEarth
{
    //Definitions for the mercator extent
    const double MERC_MINX = -2.00375e+007;
    const double MERC_MINY = -2.00375e+007;
    const double MERC_MAXX = 2.00375e+007;
    const double MERC_MAXY = 2.00375e+007;
    const double MERC_WIDTH = MERC_MAXX - MERC_MINX;
    const double MERC_HEIGHT = MERC_MAXY - MERC_MINY;


    class OSGEARTH_EXPORT GeoLocator;

    class OSGEARTH_EXPORT SpatialReference : public osg::Referenced
    {
    public:
        static SpatialReference* create( const std::string& init );

        static SpatialReference* create( osg::CoordinateSystemNode* csn );

        static SpatialReference* createFromHandle( void* ogrHandle, bool xferOwnership =false );

    public:
        virtual bool transform(
            double x, double y, double z,
            const SpatialReference* to_srs,
            double& out_x, double& out_y, double& out_z,
            void* context =0L ) const;

        bool transform(
            const osg::Vec3d&       input,
            const SpatialReference* to_srs,
            osg::Vec3d&             output,
            void*                   context =0L) const
        {
            return transform(input.x(), input.y(), input.z(), to_srs, output.x(), output.y(), output.z(), context);
        }

        bool transform2D(
            double x, double y,
            const SpatialReference* to_srs,
            double& out_x, double& out_y,
            void* context =0L ) const
        {
            double dummyZ;
            return transform(x, y, dummyZ, to_srs, out_x, out_y, dummyZ, context);
        }

        virtual bool transformPoints(
            const SpatialReference* to_srs, 
            double* x, double* y, double* z,
            unsigned int numPoints,
            void* context =0L,
            bool ignore_errors =false) const;

        virtual bool transformPoints(
            const SpatialReference*  to_srs,
            std::vector<osg::Vec3d>& points,
            void* context =0L,
            bool ignore_errors =false) const;

        bool transformToECEF(
            const osg::Vec3d& input,
            osg::Vec3d& output ) const;

        bool transformToECEF(
            std::vector<osg::Vec3d>& points,
            bool                     ignore_errors =false) const;

        bool transformFromECEF(
            const osg::Vec3d& input,
            osg::Vec3d& output ) const;

        bool transformFromECEF(
            std::vector<osg::Vec3d>& points,
            bool                     ignoreErrors =false) const;

        virtual bool transformExtent(
            const SpatialReference* to_srs,
            double& in_out_xmin, double& in_out_ymin,
            double& in_out_xmax, double& in_out_ymax,
            void* context =0L ) const;

        virtual bool transformExtentPoints(
            const SpatialReference* to_srs,
            double in_xmin, double in_ymin,
            double in_xmax, double in_ymax,
            double* x, double* y,
            unsigned int numx, unsigned int numy,
            void* context = 0L, bool ignore_errors = false ) const;
        
        virtual bool isGeographic() const;

        virtual bool isProjected() const;

        bool isMercator() const;

        bool isNorthPolar() const;
        bool isSouthPolar() const;

        virtual bool isUserDefined() const;

        virtual bool isContiguous() const;

        virtual bool isCube() const;

        virtual bool isLTP() const { return _is_ltp; }

        const std::string& getName() const;

        const osg::EllipsoidModel* getEllipsoid() const;

        const std::string& getWKT() const;

        const std::string& getInitType() const;

        const std::string& getInitString() const;

        const std::string& getDatumName() const;

        virtual bool isEquivalentTo( const SpatialReference* rhs ) const;

        const SpatialReference* getGeographicSRS() const;

        SpatialReference* createTangentPlaneSRS( const osg::Vec3d& refPos ) const;

        SpatialReference* createTransMercFromLongitude( const Angular& lon ) const;

        SpatialReference* createUTMFromLongitude( const Angular& lon ) const;

        osg::CoordinateSystemNode* createCoordinateSystemNode() const;

        bool populateCoordinateSystemNode( osg::CoordinateSystemNode* csn ) const;

        virtual GeoLocator* createLocator(
            double xmin, double ymin, double xmax, double ymax,
            bool plate_carre =false ) const;



    protected:
        virtual ~SpatialReference();

    protected:
        SpatialReference( void* handle, const std::string& type, const std::string& init_str, const std::string& name );
        SpatialReference( void* handle, bool ownsHandle =true );
        void init();

        bool _initialized;
        void* _handle;
        bool _owns_handle;
        bool _is_geographic;
        bool _is_mercator;
        bool _is_north_polar, _is_south_polar;
        bool _is_cube;
        bool _is_contiguous;
        bool _is_user_defined;
        bool _is_ltp;
        std::string _name;
        std::string _wkt;
        std::string _proj4;
        std::string _init_type;
        std::string _init_str;
        std::string _init_str_lc;
        std::string _datum;
        osg::ref_ptr<osg::EllipsoidModel> _ellipsoid;
        osg::ref_ptr<SpatialReference> _geo_srs;

        typedef std::map<std::string,void*> TransformHandleCache;
        TransformHandleCache _transformHandleCache;

        // user can override these methods in a subclass to perform custom functionality; must
        // call the superclass version.
        virtual void _init();
        virtual bool _isEquivalentTo( const SpatialReference* srs ) const;

        virtual bool preTransform(double& x, double& y, double& z, void* context) const { return true; }
        virtual bool postTransform(double& x, double& y, double& z, void* context) const { return true;}
        


        typedef std::map< std::string, osg::ref_ptr<SpatialReference> > SpatialReferenceCache;
        static SpatialReferenceCache& getSpatialReferenceCache();

    private:
        static SpatialReference* createFromWKT(
            const std::string& wkt, const std::string& alias, const std::string& name ="" );

        static SpatialReference* createFromPROJ4(
            const std::string& proj4, const std::string& alias, const std::string& name ="" );

        static SpatialReference* createCube();


        SpatialReference* validate();
    };
}


#endif // OSGEARTH_SPATIAL_REFERENCE_H