/home/cube/sources/osgearth/src/osgEarth/Caching

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_CACHING_H
#define OSGEARTH_CACHING_H 1

#include <osgEarth/Common>
#include <osgEarth/Config>
#include <osgEarth/TMS>
#include <osgEarth/TileKey>

#include <osg/Referenced>
#include <osg/Object>
#include <osg/Image>
#include <osg/Shape>
#include <osg/Timer>
#include <osgDB/ReadFile>

#include <OpenThreads/ReadWriteMutex>

#include <string>
#include <list>
#include <map>

namespace osgEarth
{
    class CacheOptions : public DriverConfigOptions // no export (header only)
    {
    public:
        CacheOptions( const ConfigOptions& options =ConfigOptions() )
            : DriverConfigOptions( options ),
              _cacheOnly( false )
        { 
            fromConfig( _conf ); 
        }

        optional<bool>& cacheOnly() { return _cacheOnly; }
        const optional<bool>& cacheOnly() const { return _cacheOnly; }

    public:
        virtual Config getConfig() const {
            Config conf = ConfigOptions::getConfig();
            conf.updateIfSet( "cache_only", _cacheOnly );
            return conf;
        }
        virtual void mergeConfig( const Config& conf ) {
            ConfigOptions::mergeConfig( conf );            
            fromConfig( conf );
        }

        void setReferenceURI(const std::string& referenceURI) { _referenceURI = referenceURI; }
        const std::string& getReferenceURI() const { return _referenceURI; }

    private:
        void fromConfig( const Config& conf ) {
            conf.getIfSet( "cache_only", _cacheOnly );
        }

        optional<bool> _cacheOnly;
        std::string _referenceURI;
    };

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

    class DiskCacheOptions : public CacheOptions
    {
    public:
        DiskCacheOptions( const ConfigOptions& options =ConfigOptions() )
            : CacheOptions( options ),
              _writeWorldFiles( false ),
                          _imageWriterPluginOptions("")
        {
            fromConfig( _conf );
        }

        void setPath( const std::string& value ) { _path = value; }
        const std::string& path() const { return _path; }

        optional<bool>& writeWorldFiles() { return _writeWorldFiles; }
        const optional<bool>& writeWorldFiles() const { return _writeWorldFiles; }

        optional<std::string>& imageWriterPluginOptions() { return _imageWriterPluginOptions; }
        const optional<std::string>& imageWriterPluginOptions() const { return _imageWriterPluginOptions; }

    public:
        virtual Config getConfig() const {
            Config conf = CacheOptions::getConfig();
            conf.update("path", _path);
            conf.updateIfSet("write_world_files", _writeWorldFiles);
            conf.updateIfSet("image_writer_plugin_options", _imageWriterPluginOptions);
            return conf;
        }
        virtual void mergeConfig( const Config& conf ) {
            CacheOptions::mergeConfig( conf );
            fromConfig( conf );
        }

    private:
        void fromConfig( const Config& conf ) {
            _path = conf.value("path");
            conf.getIfSet("write_world_files", _writeWorldFiles);
            conf.getIfSet("image_writer_plugin_options", _imageWriterPluginOptions);
                        
        }

        std::string           _path;
        optional<bool>        _writeWorldFiles;
                optional<std::string> _imageWriterPluginOptions;
    };

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

    class TMSCacheOptions : public DiskCacheOptions // no export (header only)
    {
    public:
        TMSCacheOptions( const ConfigOptions& options =ConfigOptions() )
            : DiskCacheOptions( options ),
              _invertY( false )
        {
            setDriver("tms");
            fromConfig( _conf );
        }

        optional<bool>& invertY() { return _invertY; }
        const optional<bool>& invertY() const { return _invertY; }

    public:
        virtual Config getConfig() const {
            Config conf = DiskCacheOptions::getConfig();
            conf.updateIfSet("invert_y", _invertY);
            return conf;
        }
        virtual void mergeConfig( const Config& conf ) {
            DiskCacheOptions::mergeConfig( conf );
            fromConfig( conf );
        }

    private:
        void fromConfig( const Config& conf ) {
            conf.getIfSet("invert_y", _invertY);
        }

        optional<bool> _invertY;
    };

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

    struct CacheSpec
    {
        CacheSpec() { }
        CacheSpec( const std::string& cacheId, const std::string& format, const std::string& name ="")
            :  _cacheId( cacheId ), _format(format), _name(name) { }

        bool empty() const { return _cacheId.empty(); }

        const std::string& cacheId() const { return _cacheId; }
        const std::string& format() const { return _format; }
        const std::string& name() const { return _name; }

    private:
        std::string _cacheId;
        std::string _format;
        std::string _name; // this is only here so you can see what layer the cache spec is referencing.
    };

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

  class OSGEARTH_EXPORT Cache : public osg::Object
  {
  public:
    virtual bool getImage( const TileKey& key, const CacheSpec& spec, osg::ref_ptr<const osg::Image>& out_image ) =0;

    virtual void setImage( const TileKey& key, const CacheSpec& spec, const osg::Image* image ) = 0;

    virtual bool getHeightField( const TileKey& key, const CacheSpec& spec, osg::ref_ptr<const osg::HeightField>& out_hf );

    virtual void setHeightField( const TileKey& key, const CacheSpec& spec, const osg::HeightField* hf );

    virtual const std::string& getReferenceURI() { return _refURI; }

    virtual void setReferenceURI( const std::string& value ) { _refURI = value; }

    virtual bool isCached( const TileKey& key, const CacheSpec& spec) const { return false; }

    virtual void storeProperties( const CacheSpec& spec, const Profile* profile, unsigned int tileSize ) 
        { }

    virtual bool loadProperties( 
        const std::string&           cacheId, 
        CacheSpec&                   out_spec, 
        osg::ref_ptr<const Profile>& out_profile,
        unsigned int&                out_tileSize ) { return false; }

    virtual bool compact( bool async =true ) { return false; }

    virtual bool purge(
        const std::string& cacheId,
        int olderThanTimeStamp =0L,
        bool async =true ) { return false; }

    const CacheOptions& getCacheOptions() const { return _options; }

  public:
      Cache( const CacheOptions& options =CacheOptions() );
      Cache( const Cache& rhs, const osg::CopyOp& op =osg::CopyOp::DEEP_COPY_ALL );

  protected:
      CacheOptions _options;
      std::string _refURI;
  };

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

  class OSGEARTH_EXPORT MemCache : public Cache
  {
  public:
    MemCache( int maxTilesInCache =16 );
    MemCache( const MemCache& rhs, const osg::CopyOp& op =osg::CopyOp::DEEP_COPY_ALL );
    META_Object(osgEarth,MemCache);

    unsigned int getMaxNumTilesInCache() const;

    void setMaxNumTilesInCache(unsigned int max);

    virtual bool isCached( const TileKey& key, const CacheSpec& spec ) const;

    virtual bool getImage( const TileKey& key, const CacheSpec& spec, osg::ref_ptr<const osg::Image>& out_image );

    virtual void setImage( const TileKey& key, const CacheSpec& spec, const osg::Image* image );

    virtual bool getHeightField( const TileKey& key, const CacheSpec& spec, osg::ref_ptr<const osg::HeightField>& out_hf );

    virtual void setHeightField( const TileKey& key, const CacheSpec& spec, const osg::HeightField* hf );

    virtual bool purge( const std::string& cacheId, int olderThan, bool async );

  protected:
    bool getObject( const TileKey& key, const CacheSpec& spec, osg::ref_ptr<const osg::Object>& out_result );

    void setObject( const TileKey& key, const CacheSpec& spec, const osg::Object* image );

    struct CachedObject
    {
      std::string _key;
      osg::ref_ptr<const osg::Object> _object;
    };

    typedef std::list<CachedObject> ObjectList;
    ObjectList _objects;

    typedef std::map<std::string,ObjectList::iterator> KeyToIteratorMap;
    KeyToIteratorMap _keyToIterMap;

    unsigned int _maxNumTilesInCache;
    OpenThreads::Mutex _mutex;

  };

  class OSGEARTH_EXPORT DiskCache : public Cache
  {
  public:
    DiskCache( const DiskCacheOptions& options =DiskCacheOptions() );

    DiskCache( const DiskCache& rhs, const osg::CopyOp& op =osg::CopyOp::DEEP_COPY_ALL );

    META_Object(osgEarth,DiskCache);

    std::string getPath() const;

    virtual bool isCached( const TileKey& key, const CacheSpec& spec ) const;

    virtual std::string getFilename( const TileKey& key, const CacheSpec& spec ) const;

    virtual bool getImage( const TileKey& key, const CacheSpec& spec, osg::ref_ptr<const osg::Image>& out_image );

    virtual void setImage( const TileKey& key, const CacheSpec& spec, const osg::Image* image );

    virtual void storeProperties( const CacheSpec& spec, const Profile* profile, unsigned int tileSize );

    virtual bool loadProperties( 
        const std::string&           cacheId, 
        CacheSpec&                   out_spec, 
        osg::ref_ptr<const Profile>& out_profile,
        unsigned int&                out_tileSize );


  protected:
    std::string getTMSPath(const std::string& cacheId) const;

    struct LayerProperties
    {
      std::string _format;
      unsigned int _tile_size;
      osg::ref_ptr< const Profile > _profile;
    };

    typedef std::map< std::string, LayerProperties > LayerPropertiesCache;
    LayerPropertiesCache _layerPropertiesCache;
    bool        _writeWorldFilesOverride;     

  private:
      DiskCacheOptions _options;
  };

  class OSGEARTH_EXPORT TMSCache : public DiskCache
  {
  public:
    TMSCache(const TMSCacheOptions& options =TMSCacheOptions() );

    TMSCache(const TMSCache& rhs, const osg::CopyOp& op =osg::CopyOp::DEEP_COPY_ALL);
    META_Object(osgEarth,TMSCache);

    const bool& getInvertY() {return _invertY; }

    void setInvertY(const bool &invertY) {_invertY = invertY;}

    virtual std::string getFilename( const TileKey& key, const CacheSpec& spec ) const;

  private:
    bool _invertY;
    TMSCacheOptions _options;
  };

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

  class OSGEARTH_EXPORT CacheDriver : public osgDB::ReaderWriter
  {
  public:
      const CacheOptions& getCacheOptions( const osgDB::ReaderWriter::Options* options ) const;
  };

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

  class OSGEARTH_EXPORT CacheFactory
  {
  public:
      static Cache* create( const CacheOptions& options);
  };
}

#endif // OSGEARTH_CACHING_H