/home/cube/sources/osgearth/src/osgEarth/ImageLayer

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_IMAGE_TERRAIN_LAYER_H
#define OSGEARTH_IMAGE_TERRAIN_LAYER_H 1

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

namespace osgEarth
{
    class OSGEARTH_EXPORT ImageLayerOptions : public TerrainLayerOptions
    {
    public:
        ImageLayerOptions( const ConfigOptions& options =ConfigOptions() );

        ImageLayerOptions( const std::string& name, const TileSourceOptions& driverOpt =TileSourceOptions() );


    public: // properties

        optional<float>& opacity() { return _opacity; }
        const optional<float>& opacity() const { return _opacity; }

        optional<float>& minVisibleRange() { return _minRange; }
        const optional<float>& minVisibleRange() const { return _minRange; }

        optional<float>& maxVisibleRange() { return _maxRange; }
        const optional<float>& maxVisibleRange() const { return _maxRange; }

        optional<std::string>& noDataImageFilename() { return _noDataImageFilename; }
        const optional<std::string>& noDataImageFilename() const { return _noDataImageFilename; }

                optional<osg::Vec4ub>& transparentColor() { return _transparentColor; }
        const optional<osg::Vec4ub>& transparentColor() const { return _transparentColor; }

                optional<osg::Texture::FilterMode>& magFilter(void) {return _magFilter;}
                const optional<osg::Texture::FilterMode>& magFilter(void) const {return _magFilter;}

                optional<osg::Texture::FilterMode>& minFilter(void) {return _minFilter;}
                const optional<osg::Texture::FilterMode>& minFilter(void) const {return _minFilter;}

        optional<bool>& lodBlending() { return _lodBlending; }
        const optional<bool>& lodBlending() const { return _lodBlending; }

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

                optional<float>  _opacity;
        optional<float>  _minRange;
        optional<float>  _maxRange;
                optional<osg::Vec4ub> _transparentColor;
            optional<std::string> _noDataImageFilename;
                optional<osg::Texture::FilterMode> _magFilter;
        optional<osg::Texture::FilterMode> _minFilter;
        optional<bool> _lodBlending;
    };

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

    struct ImageLayerCallback : public TerrainLayerCallback
    {
        virtual void onOpacityChanged( class ImageLayer* layer ) { }        
    };

    typedef void (ImageLayerCallback::*ImageLayerCallbackMethodPtr)(ImageLayer* layer);

    typedef std::list< osg::ref_ptr<ImageLayerCallback> > ImageLayerCallbackList;

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

    class ImageLayerTileProcessor 
    {
    public:
        ImageLayerTileProcessor( const ImageLayerOptions& options =ImageLayerOptions() );

        void init( const ImageLayerOptions& options, bool layerInTargetProfile );

        void process( osg::ref_ptr<osg::Image>& image ) const;

    private:
        ImageLayerOptions _options;
        osg::Vec4f _chromaKey;
        osg::ref_ptr<const osg::Image> _noDataImage;
        bool _layerInTargetProfile;
    };

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

    class OSGEARTH_EXPORT ImageLayer : public TerrainLayer
    {
    public:
        ImageLayer( const ImageLayerOptions& options );

        ImageLayer( const std::string& name, const TileSourceOptions& driverOptions );

        ImageLayer( const ImageLayerOptions& options, TileSource* tileSource );

    public:
        const ImageLayerOptions& getImageLayerOptions() const { return _runtimeOptions; }
        virtual const TerrainLayerOptions& getTerrainLayerOptions() const { return _runtimeOptions; }

        void addCallback( ImageLayerCallback* cb );

        void removeCallback( ImageLayerCallback* cb );

        virtual void setTargetProfileHint( const Profile* profile );

    public: // runtime properties

        void setOpacity( float opacity );
        float getOpacity() const { return *_runtimeOptions.opacity(); }
        
        void disableLODBlending();
        bool isLODBlendingEnabled() const { return *_runtimeOptions.lodBlending(); }

    public: // methods

                GeoImage createImage( const TileKey& key, ProgressCallback* progress = 0);

    protected:

        osg::Image* createImageWrapper(
            const TileKey& key,
            bool cacheInLayerProfile,
            ProgressCallback* progress );

        virtual void initTileSource();
    private:
        //const ImageLayerOptions _options;
        ImageLayerOptions       _runtimeOptions;

        //float _actualOpacity;        
        //bool  _actualLODBlending;

        osg::ref_ptr<TileSource::ImageOperation> _preCacheOp;
        
        void initPreCacheOp();

        ImageLayerCallbackList _callbacks;
        virtual void fireCallback( TerrainLayerCallbackMethodPtr method );
        virtual void fireCallback( ImageLayerCallbackMethodPtr method );

        void init();
    };

    typedef std::vector< osg::ref_ptr<ImageLayer> > ImageLayerVector;

} // namespace osgEarth

#endif // OSGEARTH_IMAGE_TERRAIN_LAYER_H