/home/cube/sources/osgearth/src/osgEarth/TerrainLayer

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_TERRAIN_LAYER_H
#define OSGEARTH_TERRAIN_LAYER_H 1

#include <osgEarth/Common>
#include <osgEarth/Layer>
#include <osgEarth/Config>
#include <osgEarth/TileSource>
#include <osgEarth/Profile>
#include <osgEarth/Caching>
#include <osgEarth/ThreadingUtils>

namespace osgEarth
{
    class OSGEARTH_EXPORT TerrainLayerOptions : public ConfigOptions
    {
    public:
        TerrainLayerOptions( const ConfigOptions& options =ConfigOptions() );
        TerrainLayerOptions( const std::string& name, const TileSourceOptions& driverOptions );

        std::string& name() { return _name; }
        const std::string& name() const { return _name; }

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

        optional<TileSourceOptions>& driver() { return _driver; }
        const optional<TileSourceOptions>& driver() const { return _driver; }

        optional<int>& minLevel() { return _minLevel; }
        const optional<int>& minLevel() const { return _minLevel; }

        optional<double>& minLevelResolution() { return _minLevelResolution;}
        const optional<double>& minLevelResolution() const { return _minLevelResolution; }


        optional<int>& maxLevel() { return _maxLevel; }
        const optional<int>& maxLevel() const { return _maxLevel; }

        optional<double>& maxLevelResolution() { return _maxLevelResolution; }
        const optional<double>& maxLevelResolution() const { return _maxLevelResolution; }

        optional<unsigned int>& maxDataLevel() { return _maxDataLevel; }
        const optional<unsigned int>& maxDataLevel() const { return _maxDataLevel; }



        optional<bool>& enabled() { return _enabled; }
        const optional<bool>& enabled() const { return _enabled; }

        optional<bool>& exactCropping() { return _exactCropping; }
        const optional<bool>& exactCropping() const { return _exactCropping; }

        optional<unsigned int> reprojectedTileSize() { return _reprojectedTileSize; }
        const optional<unsigned int> reprojectedTileSize() const { return _reprojectedTileSize; }

        optional<std::string>& cacheFormat() { return _cacheFormat; }
        const optional<std::string>& cacheFormat() const { return _cacheFormat; }

        optional<bool>& cacheEnabled() { return _cacheEnabled; }
        const optional<bool>& cacheEnabled() const { return _cacheEnabled; }

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

        optional<std::string>& cacheId() { return _cacheId; }
        const optional<std::string>& cacheId() const { return _cacheId; }
        
        optional<float>& loadingWeight() { return _loadingWeight; }
        const optional<float>& loadingWeight() const { return _loadingWeight; }

        optional<double>& edgeBufferRatio() { return _edgeBufferRatio;}
        const optional<double>& edgeBufferRatio() const { return _edgeBufferRatio; }

    public:
        virtual Config getConfig() const;
        virtual void mergeConfig( const Config& conf );

    private:
        void fromConfig( const Config& conf );
        void setDefaults();
       
        std::string _name;
        optional<ProfileOptions> _profile;
        optional<TileSourceOptions> _driver;
        optional<int> _minLevel;
        optional<int> _maxLevel;
        optional<double> _minLevelResolution;
        optional<double> _maxLevelResolution;
                optional<std::string> _cacheFormat;
        optional<bool> _cacheEnabled;
                optional<bool> _cacheOnly;
        optional<float> _loadingWeight;
        optional<bool> _exactCropping;
                optional<bool> _enabled;
                optional<unsigned int> _reprojectedTileSize;
        optional<double> _edgeBufferRatio;
        optional<std::string> _cacheId;
        optional<unsigned int> _maxDataLevel;
    };

    struct TerrainLayerCallback : public osg::Referenced
    {
        virtual void onEnabledChanged( class TerrainLayer* layer ) { }
    };

    typedef void (TerrainLayerCallback::*TerrainLayerCallbackMethodPtr)(TerrainLayer* layer);


    class OSGEARTH_EXPORT TerrainLayer : public Layer
    {
    protected:
        TerrainLayer( TerrainLayerOptions* options );
        
        TerrainLayer( TerrainLayerOptions* options, TileSource* tileSource );

    public:

        const TerrainLayerOptions& getTerrainLayerOptions() const {
            return *_runtimeOptions; }

        void setEnabled( bool value );
        bool getEnabled() const { return *_runtimeOptions->enabled(); }

        const std::string& getName() const { 
            return getTerrainLayerOptions().name(); }

                const Profile* getProfile() const;

        TileSource* getTileSource() const;

        unsigned int getTileSize() const;

                unsigned int getMaxDataLevel() const;

        bool isDynamic() const;

        const std::string& getCacheFormat() const {  return *_runtimeOptions->cacheFormat(); }

    public: // methods

                bool isKeyValid(const TileKey& key) const;

        Cache* getCache() const { return _cache.get(); }

                void setCache( Cache* cache );

        const CacheSpec& getCacheSpec() const { return _cacheSpec; }
        
        virtual void setTargetProfileHint( const Profile* profile );

        bool isCacheOnly() const { return *_runtimeOptions->cacheOnly(); }

    protected:

                virtual void initTileSource();

        virtual std::string suggestCacheFormat() const;

    protected:

        osg::ref_ptr<TileSource> _tileSource;
                osg::ref_ptr<Cache>      _cache;
        CacheSpec                _cacheSpec;

                osg::ref_ptr<const Profile> _profile;
        osg::ref_ptr<const Profile> _cacheProfile;
        osg::ref_ptr<const Profile> _targetProfileHint;

        bool                        _tileSourceInitialized;
                unsigned                    _tileSize;        

    private:
        std::string          _name;
        std::string          _referenceURI;
        OpenThreads::Mutex   _initTileSourceMutex;
        TerrainLayerOptions* _runtimeOptions;

        void init();
        virtual void fireCallback( TerrainLayerCallbackMethodPtr method ) =0;

        // methods accesible by Map:
        friend class Map;
        void setReferenceURI( const std::string& uri );
        void setCacheOnly( bool value );
    };

    typedef std::vector<osg::ref_ptr<TerrainLayer> > TerrainLayerVector;

} // namespace TerrainLayer

#endif // OSGEARTH_TERRAIN_LAYER_H