/home/cube/sources/osgearth/src/osgEarth/TMS

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_TMS_H
#define OSGEARTH_TMS_H 1

#include <vector>
#include <iostream>
#include <osgEarth/Profile>
#include <osgEarth/Common>

#include <osg/Referenced>
#include <osgDB/ReaderWriter>

#include <osg/Version>
#if OSG_MIN_VERSION_REQUIRED(2,9,5)
#include <osgDB/Options>
#endif

namespace osgEarth
{
    class TileSource;

    class OSGEARTH_EXPORT TileFormat
    {
    public:
        TileFormat();

        unsigned int getWidth() const {return _width;}

        void setWidth(unsigned int width) {_width = width;}

        unsigned int getHeight() const {return _height;}

        void setHeight(unsigned int height) {_height = height;}

        const std::string& getMimeType() const {return _mimeType;}

        void setMimeType(const std::string& mimeType) {_mimeType = mimeType;}

        const std::string& getExtension() const {return _extension;}

        void setExtension(const std::string& extension) {_extension = extension;}

    protected:
        unsigned int _width;
        unsigned int _height;
        std::string _mimeType;
        std::string _extension;
    };

    class OSGEARTH_EXPORT TileSet
    {
    public:
        TileSet();

        const std::string& getHref() const {return _href;}

        void setHref( const std::string &href) {_href = href;}

        double getUnitsPerPixel() const {return _unitsPerPixel;}

        void setUnitsPerPixel(double unitsPerPixel) {_unitsPerPixel = unitsPerPixel;}

        unsigned int getOrder() const {return _order;}

        void setOrder( int order ) {_order = order;}

    protected:
        std::string _href;
        double _unitsPerPixel;
        unsigned int _order;
    };

    class OSGEARTH_EXPORT TileMap : public osg::Referenced
    {
    public:
        TileMap();

        const std::string& getTileMapService() const {return _tileMapService;}

        void setTileMapService(const std::string& tileMapService) {_tileMapService = tileMapService;}

        const std::string& getVersion() const {return _version;}

        void setVersion(const std::string& version) {_version = version;}

        const std::string& getTitle() const {return _title;}

        void setTitle(const std::string& title) {_title = title;}

        const std::string& getAbstract() const {return _abstract;}

        void setAbstract(const std::string& value) {_abstract = value;}

        const std::string& getSRS() const {return _srs;}

        void setSRS(const std::string& srs) {_srs = srs;}

        const std::string& getVerticalSRS() const { return _vsrs; }

        void setVerticalSRS(const std::string& vsrs) { _vsrs = vsrs; }

        const std::string& getFilename() const {return _filename;}

        void setFilename(const std::string& filename) {_filename = filename;}

        unsigned int getMinLevel() const {return _minLevel;}

        unsigned int getMaxLevel() const {return _maxLevel;}

        void computeMinMaxLevel();

        void computeNumTiles();

        double getOriginX() const {return _originX;}

        void setOriginX(double x) {_originX = x;}

        double getOriginY() const {return _originY;}

        void setOriginY(double y) {_originY = y;}

        void setOrigin(double x, double y);

        void getExtents( double &minX, double &minY, double &maxX, double &maxY) const;

        void setExtents( double minX, double minY, double maxX, double maxY);

        unsigned int getNumTilesWide() const { return _numTilesWide; }

        void setNumTilesWide(unsigned int w) { _numTilesWide = w; }

        unsigned int getNumTilesHigh() const { return _numTilesHigh; }

        void setNumTilesHigh(unsigned int h) {_numTilesHigh = h;}

        osgEarth::Profile::ProfileType getProfileType() const {return _profile_type;}
        void setProfileType( osgEarth::Profile::ProfileType type ) {_profile_type = type;}

        const Profile* createProfile() const;

        TileFormat& getFormat() {return _format;}
        
        const TileFormat& getFormat() const {return _format;}


        typedef std::vector<TileSet> TileSetList;

        TileSetList& getTileSets() {return _tileSets;}

        const TileSetList& getTileSets() const {return _tileSets;}

        DataExtentList& getDataExtents() { return _dataExtents;}
        const DataExtentList& getDataExtents() const { return _dataExtents;}

       
        std::string getURL(const osgEarth::TileKey& tileKey, bool invertY);

        bool intersectsKey(const osgEarth::TileKey& tileKey);

        void generateTileSets(unsigned int numLevels = 20);

        static TileMap* create(
            const std::string& url,
            const Profile* profile,
            //osgEarth::Profile::ProfileType type,
            const std::string& format,
            int tile_width,
            int tile_height );

        static TileMap* create(
            const TileSource* tileSource,
            const Profile*    profile );

    protected:
        std::string _tileMapService;
        std::string _version;
        std::string _title;
        std::string _abstract;
        std::string _srs;
        std::string _vsrs;


        double _originX, _originY;

        double _minX, _minY, _maxX, _maxY;

        TileSetList _tileSets;

        TileFormat _format;

        std::string _filename;

        unsigned int _minLevel;
        unsigned int _maxLevel;

        unsigned int _numTilesWide;
        unsigned int _numTilesHigh;

        osgEarth::Profile::ProfileType _profile_type;        

        DataExtentList _dataExtents;
    };

    class OSGEARTH_EXPORT TileMapReaderWriter
    {
    public:
        static TileMap* read( const std::string &location, const osgDB::ReaderWriter::Options* options );
        static TileMap* read( std::istream &in );

        static void write(const TileMap* tileMap, const std::string& location);
        static void write(const TileMap* tileMap, std::ostream& output);

    private:
        TileMapReaderWriter();
        TileMapReaderWriter(const TileMapReaderWriter &tmr);
    };
}

#endif //OSGEARTH_TMS_H