/home/cube/sources/osgearth/src/osgEarth/TileSource

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_SOURCE_H
#define OSGEARTH_TILE_SOURCE_H 1

#include <limits.h>

#include <osg/Version>

#include <osgEarth/Common>
#include <osgEarth/TileKey>
#include <osgEarth/Profile>
#include <osgEarth/Caching>
#include <osgEarth/Progress>
#include <osgEarth/ThreadingUtils>

#include <osg/Referenced>
#include <osg/Object>
#include <osg/Image>
#include <osg/Shape>
#if OSG_MIN_VERSION_REQUIRED(2,9,5)
#include <osgDB/Options>
#endif
#include <osgDB/ReadFile>

#include <OpenThreads/Mutex>

#include <string>


#define TILESOURCE_CONFIG "tileSourceConfig"


namespace osgEarth
{   
    class TileSourceOptions : public DriverConfigOptions // no export; header only
    {
    public:
        
        optional<int>& tileSize() { return _tileSize; }
        const optional<int>& tileSize() const { return _tileSize; }

        optional<float>& noDataValue() { return _noDataValue; }
        const optional<float>& noDataValue() const { return _noDataValue; }

        optional<float>& noDataMinValue() { return _noDataMinValue; }
        const optional<float>& noDataMinValue() const { return _noDataMinValue; }

        optional<float>& noDataMaxValue() { return _noDataMaxValue; }
        const optional<float>& noDataMaxValue() const { return _noDataMaxValue; }

        optional<std::string>& blacklistFilename() { return _blacklistFilename; }
        const optional<std::string>& blacklistFilename() const { return _blacklistFilename; }

        optional<ProfileOptions>& profile() { return _profileOptions; }
        const optional<ProfileOptions>& profile() const { return _profileOptions; }

        optional<int>& L2CacheSize() { return _L2CacheSize; }
        const optional<int>& L2CacheSize() const { return _L2CacheSize; }

    public:
        TileSourceOptions( const ConfigOptions& options =ConfigOptions() )
            : DriverConfigOptions( options ),
              _tileSize( 256 ),
              _noDataValue( (float)SHRT_MIN ),
              _noDataMinValue( -FLT_MAX ),
              _noDataMaxValue( FLT_MAX ),
              _L2CacheSize( 16 )
        { 
            fromConfig( _conf );
        }

    public:
        virtual Config getConfig() const {
            Config conf = DriverConfigOptions::getConfig();
            conf.updateIfSet( "tile_size", _tileSize );
            conf.updateIfSet( "nodata_value", _noDataValue );
            conf.updateIfSet( "nodata_min", _noDataMinValue );
            conf.updateIfSet( "nodata_max", _noDataMaxValue );
            conf.updateIfSet( "blacklist_filename", _blacklistFilename);
            //conf.updateIfSet( "enable_l2_cache", _enableL2Cache );
            conf.updateIfSet( "l2_cache_size", _L2CacheSize );
            conf.updateObjIfSet( "profile", _profileOptions );
            return conf;
        }

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

    private:
        void fromConfig( const Config& conf ) {
            conf.getIfSet( "tile_size", _tileSize );
            conf.getIfSet( "nodata_value", _noDataValue );
            conf.getIfSet( "nodata_min", _noDataMinValue );
            conf.getIfSet( "nodata_max", _noDataMaxValue );
            conf.getIfSet( "blacklist_filename", _blacklistFilename);
            //conf.getIfSet( "enable_l2_cache", _enableL2Cache );
            conf.getIfSet( "l2_cache_size", _L2CacheSize );
            conf.getObjIfSet( "profile", _profileOptions );

            // special handling of default tile size:
            if ( !tileSize().isSet() )
                conf.getIfSet( "default_tile_size", _tileSize );
            // remove it now so it does not get serialized
            _conf.remove( "default_tile_size" );
        }

        optional<int> _tileSize;
        optional<float> _noDataValue, _noDataMinValue, _noDataMaxValue;
        optional<ProfileOptions> _profileOptions;
        optional<std::string> _blacklistFilename;
        optional<int> _L2CacheSize;
        //optional<bool> _enableL2Cache;
    };

    typedef std::vector<TileSourceOptions> TileSourceOptionsVector;

    class OSGEARTH_EXPORT TileBlacklist : public virtual osg::Referenced
    {
    public:
        TileBlacklist();

        void add(const osgTerrain::TileID &tile);

        void remove(const osgTerrain::TileID& tile);

        void clear();

        bool contains(const osgTerrain::TileID &tile) const;

        unsigned int size() const;

        static TileBlacklist* read(std::istream &in);

        static TileBlacklist* read(const std::string &filename);

        void write(std::ostream &output) const;

        void write(const std::string &filename) const;

    private:
        typedef std::set< osgTerrain::TileID > BlacklistedTiles;
        BlacklistedTiles _tiles;
        osgEarth::Threading::ReadWriteMutex _mutex;
    };

    class OSGEARTH_EXPORT TileSource : public virtual osg::Object
    {
    public:
        struct ImageOperation : public osg::Referenced {
            virtual void operator()( osg::ref_ptr<osg::Image>& in_out_image ) =0;
        };

        struct HeightFieldOperation : public osg::Referenced {
            virtual void operator()( osg::ref_ptr<osg::HeightField>& in_out_hf ) =0;
        };

    public:        
        TileSource( const TileSourceOptions& options =TileSourceOptions() );

        virtual int getPixelsPerTile() const;   

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

        virtual osg::Image* createImage(
            const TileKey& key,
            ImageOperation* op =0L,
            ProgressCallback* progress =0L );

        virtual osg::HeightField* createHeightField(
            const TileKey& key,
            HeightFieldOperation* prepOp =0L,
            ProgressCallback* progress = 0L );     

    public:

        virtual bool isOK() const;
        bool isValid() const { return isOK(); }

        virtual const Profile* getProfile() const;

        virtual float getNoDataValue() {
            return _options.noDataValue().value(); }

        virtual float getNoDataMinValue() {
            return _options.noDataMinValue().value(); }

        virtual float getNoDataMaxValue() {
            return _options.noDataMaxValue().value(); }

        virtual unsigned int getMaxDataLevel() const;

        virtual unsigned int getMinDataLevel() const;

        virtual bool supportsPersistentCaching() const;

        virtual std::string getExtension() const {return "png";}

        TileBlacklist* getBlacklist();
        const TileBlacklist* getBlacklist() const;     

        virtual bool hasData(const TileKey& key) const;

        virtual bool hasDataAtLOD( unsigned lod ) const;

        virtual bool hasDataInExtent( const GeoExtent& extent ) const;

        virtual bool isDynamic() const { return false; }


        virtual osg::Object* cloneType() const { return 0; } // cloneType() not appropriate
        virtual osg::Object* clone(const osg::CopyOp&) const { return 0; } // clone() not appropriate
        virtual bool isSameKindAs(const osg::Object* obj) const { return dynamic_cast<const TileSource*>(obj)!=NULL; }
        virtual const char* className() const { return "TileSource"; }
        virtual const char* libraryName() const { return "osgEarth"; }

                virtual void initialize( const std::string& referenceURI, const Profile* overrideProfile = NULL) = 0;

        const TileSourceOptions& getOptions() const {
            return _options; }
   
    protected:

        virtual ~TileSource();

                virtual osg::Image* createImage( const TileKey& key, ProgressCallback* progress ) = 0;

        virtual osg::HeightField* createHeightField( const TileKey& key, ProgressCallback* progress );

                void setProfile( const Profile* profile );

    private:
        osg::ref_ptr<const Profile> _profile;
        const TileSourceOptions _options;

        friend class Map;
        friend class MapEngine;
        friend class TileSourceFactory;

        osg::ref_ptr< TileBlacklist > _blacklist;
        std::string _blacklistFilename;

                osg::ref_ptr<MemCache> _memCache;

        DataExtentList _dataExtents;
        //osg::ref_ptr< RTree<unsigned int> > _dataExtentsIndex;
    };

    
    typedef std::vector< osg::ref_ptr<TileSource> > TileSourceVector;

    //--------------------------------------------------------------------

    class OSGEARTH_EXPORT TileSourceDriver : public osgDB::ReaderWriter
    {
    protected:
        const TileSourceOptions& getTileSourceOptions( const osgDB::ReaderWriter::Options* rwOpt ) const;
    };

    //--------------------------------------------------------------------

    class OSGEARTH_EXPORT TileSourceFactory
    {   
        public:
        static TileSource* create( const TileSourceOptions& options );
    };
}

#endif // OSGEARTH_TILE_SOURCE_H