/home/cube/sources/osgearth/src/osgEarth/Profile

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_TILE_GRID_PROFILE_H
#define OSGEARTH_TILE_GRID_PROFILE_H 1

#include <osgEarth/Common>
#include <osgEarth/Config>
#include <osgEarth/GeoData>
#include <osgEarth/SpatialReference>
#include <osgEarth/VerticalSpatialReference>
#include <osg/CoordinateSystemNode>
#include <vector>

namespace osgEarth
{
    class TileKey;

    class OSGEARTH_EXPORT ProfileOptions : public ConfigOptions
    {
    public:
        ProfileOptions( const ConfigOptions& options =ConfigOptions() );
        ProfileOptions( const std::string& namedProfile );

        bool defined() const;

    public: // properties

        optional<std::string>& namedProfile() { return _namedProfile; }
        const optional<std::string>& namedProfile() const { return _namedProfile; }

        optional<std::string>& srsString() { return _srsInitString; }
        const optional<std::string>& srsString() const { return _srsInitString; }

        optional<std::string>& vsrsString() { return _vsrsInitString; }
        const optional<std::string>& vsrsString() const { return _vsrsInitString; }

        optional<Bounds>& bounds() { return _bounds; }
        const optional<Bounds>& bounds() const { return _bounds; }

        optional<int>& numTilesWideAtLod0() { return _numTilesWideAtLod0; }
        const optional<int>& numTilesWideAtLod0() const { return _numTilesWideAtLod0; }

        optional<int>& numTilesHighAtLod0() { return _numTilesHighAtLod0; }
        const optional<int>& numTilesHighAtLod0() const { return _numTilesHighAtLod0; }

    public:
        Config getConfig() const;

    protected:
        void mergeConfig( const Config& conf ) {
            ConfigOptions::mergeConfig( conf );
            fromConfig( conf );
        }

    private:
        void fromConfig( const Config& conf );

        optional<std::string> _namedProfile;
        optional<std::string> _srsInitString;
        optional<std::string> _vsrsInitString;
        optional<Bounds>      _bounds;
        optional<int>         _numTilesWideAtLod0;
        optional<int>         _numTilesHighAtLod0;
    };

    class OSGEARTH_EXPORT Profile : public osg::Referenced
    {
    public:
        // profile types:
        enum ProfileType
        {
            TYPE_UNKNOWN,
            TYPE_GEODETIC,
            TYPE_MERCATOR,
            TYPE_LOCAL
        };

    public:

        static const Profile* create(
            const std::string& srs_string,
            double xmin, double ymin, double xmax, double ymax,
            const std::string& vsrs_string ="",
            unsigned int numTilesWideAtLod0 =0,
            unsigned int numTilesHighAtLod0 =0 );

        static const Profile* create(
            const SpatialReference* srs,
            double xmin, double ymin, double xmax, double ymax,
            double geoxmin, double geoymin, double geoxmax, double geoymax,
            const VerticalSpatialReference* vsrs =0L,
            unsigned int numTilesWideAtLod0 =0,
            unsigned int numTilesHighAtLod0 =0 );

        static const Profile* create(
            const SpatialReference* srs,
            double xmin, double ymin, double xmax, double ymax,
            const VerticalSpatialReference* vsrs =0L,
            unsigned int numTilesWideAtLod0 =0,
            unsigned int numTilesHighAtLod0 =0 );

        static const Profile* create(
            const std::string& srs_string,
            const std::string& vsrs_string ="",
            unsigned int numTilesWideAtLod0 =0,
            unsigned int numTilesHighAtLod0 =0 );

        static const Profile* create(
            const ProfileOptions& options );

        bool isOK() const;

        const GeoExtent& getExtent() const;

        const GeoExtent& getLatLongExtent() const;
        
        const SpatialReference* getSRS() const;

        const VerticalSpatialReference* getVerticalSRS() const { return _vsrs.get(); }
        void setVerticalSRS( const VerticalSpatialReference* value ) { _vsrs = value; }

        ProfileType getProfileType() const;  

        unsigned int getLevelOfDetailForHorizResolution( double resolution, int tileSize ) const;

        void getRootKeys(std::vector<TileKey>& out_keys ) const;

        virtual GeoExtent calculateExtent( unsigned int lod, unsigned int tileX, unsigned int tileY );

        static ProfileType getProfileTypeFromSRS(const std::string &srs);

        bool isEquivalentTo( const Profile* rhs ) const;

        void getTileDimensions(unsigned int lod, double& out_width, double& out_height) const;

        void getNumTiles(unsigned int lod, unsigned int& out_tiles_wide, unsigned int& out_tiles_high) const;

        void getIntersectingTiles(
            const TileKey& key,
            std::vector<TileKey>& out_intersectingKeys) const;

        virtual void getIntersectingTiles(
            const GeoExtent& extent,
            std::vector<TileKey>& out_intersectingKeys) const;

        GeoExtent clampAndTransformExtent( const GeoExtent& input, bool* out_clamped =0L ) const;

        TileKey createTileKey( double x, double y, unsigned int level ) const;

        std::string toString() const;

    protected:       

        Profile(
            const SpatialReference* srs,
            double xmin, double ymin, double xmax, double ymax,
            const VerticalSpatialReference* vsrs,
            unsigned int x_tiles_at_lod0 =0,
            unsigned int y_tiles_at_lod0 =0 );      

        Profile(
            const SpatialReference* srs,
            double xmin, double ymin, double xmax, double ymax,
            double geoxmin, double geoymin, double geoxmax, double geoymax,
            const VerticalSpatialReference* vsrs,
            unsigned int x_tiles_at_lod0 =0,
            unsigned int y_tiles_at_lod0 =0 );
        

        virtual void addIntersectingTiles(
            const GeoExtent& key_ext,
            std::vector<TileKey>& out_intersectingKeys) const;


    private:

        GeoExtent _extent;
        GeoExtent _latlong_extent;
        osg::ref_ptr<const VerticalSpatialReference> _vsrs;
        unsigned int _numTilesWideAtLod0;
        unsigned int _numTilesHighAtLod0;
    };
}

#endif // OSGEARTH_TILE_GRID_PROFILE_H