/home/cube/sources/osgearth/src/osgEarth/Map

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_MAP_H
#define OSGEARTH_MAP_H 1

#include <osgEarth/Common>
#include <osgEarth/Caching>
#include <osgEarth/Profile>
#include <osgEarth/MapOptions>
#include <osgEarth/ImageLayer>
#include <osgEarth/ElevationLayer>
#include <osgEarth/ModelLayer>
#include <osgEarth/MaskLayer>
#include <osgEarth/Revisioning>
#include <osgEarth/ThreadingUtils>
#include <osgDB/ReaderWriter>
#include <osg/TransferFunction>

namespace osgEarth
{    
    class MapInfo;

    struct MapModelChange
    {
        enum ActionType {
            ADD_IMAGE_LAYER,
            REMOVE_IMAGE_LAYER,
            MOVE_IMAGE_LAYER,
            ADD_ELEVATION_LAYER,
            REMOVE_ELEVATION_LAYER,
            MOVE_ELEVATION_LAYER,
            ADD_MODEL_LAYER,
            REMOVE_MODEL_LAYER,
            MOVE_MODEL_LAYER,
            ADD_MASK_LAYER,
            REMOVE_MASK_LAYER,
            UNSPECIFIED
        };

        MapModelChange( ActionType action, Revision mapModeRev, Layer* layer, int firstIndex =-1, int secondIndex =-1 ) 
            : _action(action), _layer(layer), _modelRevision(mapModeRev), _firstIndex(firstIndex), _secondIndex(secondIndex) { }

        const ActionType& getAction() const { return _action; }
        const Revision& getRevision() const { return _modelRevision; }
        int getFirstIndex() const { return _firstIndex; }
        int getSecondIndex() const { return _secondIndex; }
        Layer* getLayer() const { return _layer.get(); }
        ImageLayer* getImageLayer() const { return static_cast<ImageLayer*>(_layer.get()); }
        ElevationLayer* getElevationLayer() const { return static_cast<ElevationLayer*>(_layer.get()); }
        ModelLayer* getModelLayer() const { return static_cast<ModelLayer*>(_layer.get()); }
        MaskLayer* getMaskLayer() const { return static_cast<MaskLayer*>(_layer.get()); }

    private:
        ActionType _action;
        osg::ref_ptr<Layer> _layer;
        Revision _modelRevision;
        int _firstIndex, _secondIndex;
    };

    struct OSGEARTH_EXPORT MapCallback : public osg::Referenced
    {
        virtual void onMapInfoEstablished( const MapInfo& mapInfo ) { } 

        virtual void onMapModelChanged( const MapModelChange& change );

        virtual void onImageLayerAdded( ImageLayer* layer, unsigned int index ) { }
        virtual void onImageLayerRemoved( ImageLayer* layer, unsigned int index ) { }
        virtual void onImageLayerMoved( ImageLayer* layer, unsigned int oldIndex, unsigned int newIndex ) { }

        virtual void onElevationLayerAdded( ElevationLayer* layer, unsigned int index ) { }
        virtual void onElevationLayerRemoved( ElevationLayer* layer, unsigned int index ) { }
        virtual void onElevationLayerMoved( ElevationLayer* layer, unsigned int oldIndex, unsigned int newIndex ) { }

        virtual void onModelLayerAdded( ModelLayer* layer, unsigned int index ) { }
        virtual void onModelLayerRemoved( ModelLayer* layer ) { }
        virtual void onModelLayerMoved( ModelLayer* layer, unsigned int oldIndex, unsigned int newIndex ) { }

        virtual void onMaskLayerAdded( MaskLayer* mask ) { }
        virtual void onMaskLayerRemoved( MaskLayer* mask ) { }
    };

    typedef std::list< osg::ref_ptr<MapCallback> > MapCallbackList;

    class OSGEARTH_EXPORT Map : public osg::Referenced
    {
    public:
        Map( const MapOptions& options =MapOptions() );

    public:
        const MapOptions& getMapOptions() const { return _mapOptions; }

        const Profile* getProfile() const;

        int getImageLayers( ImageLayerVector& out_layers, bool validLayersOnly =false ) const;

        int getNumImageLayers() const;

        ImageLayer* getImageLayerByName( const std::string& name ) const;

        ImageLayer* getImageLayerByUID( UID layerUID ) const;

        ImageLayer* getImageLayerAt( int index ) const;

        int getElevationLayers( ElevationLayerVector& out_layers, bool validLayersOnly =false ) const;

        int getNumElevationLayers() const;

        ElevationLayer* getElevationLayerByName( const std::string& name ) const;

        ElevationLayer* getElevationLayerByUID( UID layerUID ) const;

        ElevationLayer* getElevationLayerAt( int index ) const;

        int getModelLayers( ModelLayerVector& out_layers, bool validLayersOnly =false ) const;

        int getNumModelLayers() const;

        ModelLayer* getModelLayerByName( const std::string& name ) const;

        ModelLayer* getModelLayerByUID( UID layerUID ) const;

        ModelLayer* getModelLayerAt( int index ) const;

        int getTerrainMaskLayers( MaskLayerVector& out_list ) const;

        void addMapCallback( MapCallback* callback ) const;

        void removeMapCallback( MapCallback* callback );

        void addImageLayer( ImageLayer* layer );

        void insertImageLayer( ImageLayer* layer, unsigned int index );

        void removeImageLayer( ImageLayer* layer );

        void moveImageLayer( ImageLayer* layer, unsigned int newIndex );

        void addElevationLayer( ElevationLayer* layer );

        void removeElevationLayer( ElevationLayer* layer );

        void moveElevationLayer( ElevationLayer* layer, unsigned int newIndex );

        void addModelLayer( ModelLayer* layer );

        void insertModelLayer( ModelLayer* layer, unsigned int index );

        void removeModelLayer( ModelLayer* layer );

        void moveModelLayer( ModelLayer* layer, unsigned int newIndex );

        void addTerrainMaskLayer( MaskLayer* layer );

        void removeTerrainMaskLayer( MaskLayer* layer );

    public:
        const osgDB::ReaderWriter::Options* getGlobalOptions() const;

        void setGlobalOptions( const osgDB::ReaderWriter::Options* options );

        void setName( const std::string& name );

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

        bool getHeightField(
            const TileKey& key,
            bool fallback,
            osg::ref_ptr<osg::HeightField>& out_hf,
            bool* out_isFallback =0L,
            ElevationInterpolation interpolation =INTERP_AVERAGE,
            ElevationSamplePolicy samplePolicy =SAMPLE_FIRST_VALID,
            ProgressCallback* progress = 0) const;

                void setCache( Cache* cache );

                Cache* getCache() const;

        Revision getDataModelRevision() const;

        bool isGeocentric() const;

        bool toMapPoint( const osg::Vec3d& input, const SpatialReference* input_srs, osg::Vec3d& output ) const;

        bool mapPointToWorldPoint( const osg::Vec3d& input, osg::Vec3d& output ) const;

        bool worldPointToMapPoint( const osg::Vec3d& input, osg::Vec3d& output ) const;

        bool sync( class MapFrame& frame ) const;    

        enum ModelParts {
            IMAGE_LAYERS     = 1 << 0,
            ELEVATION_LAYERS = 1 << 1,
            TERRAIN_LAYERS   = IMAGE_LAYERS | ELEVATION_LAYERS,
            MODEL_LAYERS     = 1 << 2,
            MASK_LAYERS      = 1 << 3,
            MASKED_TERRAIN_LAYERS = TERRAIN_LAYERS | MASK_LAYERS,
            ENTIRE_MODEL     = 0xff
        };

    protected:

        ~Map() { }

    private:

        MapOptions _mapOptions;
        std::string _name;
        ImageLayerVector _imageLayers;
        ElevationLayerVector _elevationLayers;
        ModelLayerVector _modelLayers;
        MaskLayerVector _terrainMaskLayers;
        MapCallbackList _mapCallbacks;
        osg::ref_ptr<const osgDB::ReaderWriter::Options> _globalOptions;
        Threading::ReadWriteMutex _mapDataMutex;
        osg::ref_ptr<const Profile> _profile;
                osg::ref_ptr<Cache> _cache;
        Revision _dataModelRevision;

    private:
        void calculateProfile();
    };


    class OSGEARTH_EXPORT MapInfo
    {
    public:
        MapInfo( const Map* map )
            : _profile( map->getProfile() ),
              _isGeocentric( map->isGeocentric() ),
              _isCube( map->getMapOptions().coordSysType() == MapOptions::CSTYPE_GEOCENTRIC_CUBE ) { }

        MapInfo( const MapInfo& rhs )
            : _profile( rhs._profile ),
              _isGeocentric( rhs._isGeocentric ),
              _isCube( rhs._isCube ) { }              
        
        const Profile* getProfile() const { return _profile.get(); }

        bool isGeocentric() const { return _isGeocentric; }
        bool isCube() const { return _isCube; }
        bool isPlateCarre() const { return !_isGeocentric && isGeographicSRS(); }

        bool isProjectedSRS() const { return !isGeographicSRS(); }
        bool isGeographicSRS() const { return _profile->getSRS()->isGeographic(); }        
        
        bool toMapPoint( const osg::Vec3d& input, const SpatialReference* input_srs, osg::Vec3d& output ) const;
        bool mapPointToWorldPoint( const osg::Vec3d& input, osg::Vec3d& output ) const;
        bool worldPointToMapPoint( const osg::Vec3d& input, osg::Vec3d& output ) const;

    private:
        osg::ref_ptr<const Profile> _profile;
        bool _isGeocentric, _isCube;
    };


    class OSGEARTH_EXPORT MapFrame
    {
    public:
        MapFrame( const Map* map, Map::ModelParts parts =Map::TERRAIN_LAYERS, const std::string& name ="" );

        MapFrame( const Map* map, bool copyValidDataOnly, Map::ModelParts parts =Map::TERRAIN_LAYERS, const std::string& name ="" );

        MapFrame( const MapFrame& frame, const std::string& name ="" );

        bool sync();

        const MapInfo& getMapInfo() const { return _mapInfo; }

        const Profile* getProfile() const { return _mapInfo.getProfile(); }

        const ImageLayerVector& imageLayers() const { return _imageLayers; }
        ImageLayer* getImageLayerAt( int index ) const { return _imageLayers[index].get(); }
        ImageLayer* getImageLayerByUID( UID uid ) const;
        ImageLayer* getImageLayerByName( const std::string& name ) const;

        const ElevationLayerVector& elevationLayers() const { return _elevationLayers; }
        ElevationLayer* getElevationLayerAt( int index ) const { return _elevationLayers[index].get(); }
        ElevationLayer* getElevationLayerByUID( UID uid ) const;
        ElevationLayer* getElevationLayerByName( const std::string& name ) const;

        const ModelLayerVector& modelLayers() const { return _modelLayers; }
        ModelLayer* getModelLayerAt(int index) const { return _modelLayers[index].get(); }

        const MaskLayerVector& terrainMaskLayers() const { return _maskLayers; }

        int indexOf( ImageLayer* layer ) const;
        int indexOf( ElevationLayer* layer ) const;
        int indexOf( ModelLayer* layer ) const;

        Revision getRevision() const { return _mapDataModelRevision; }

        bool isCached( const TileKey& key ) const;

        bool getHeightField(
            const TileKey& key,
            bool fallback,
            osg::ref_ptr<osg::HeightField>& out_hf,
            bool* out_isFallback =0L,
            ElevationInterpolation interpolation =INTERP_AVERAGE,
            ElevationSamplePolicy samplePolicy   =SAMPLE_FIRST_VALID,
            ProgressCallback* progress = 0) const; 

    private:
        bool _initialized;
        osg::ref_ptr<const Map> _map;
        std::string _name;
        MapInfo _mapInfo;
        Map::ModelParts _parts;
        bool _copyValidDataOnly;
        Revision _mapDataModelRevision;
        ImageLayerVector _imageLayers;
        ElevationLayerVector _elevationLayers;
        ModelLayerVector _modelLayers;
        MaskLayerVector _maskLayers;
        friend class Map;
    };

}

#endif // OSGEARTH_MAP_H