/home/cube/sources/osgearth/src/osgEarthFeatures/FeatureTileSource

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 OSGEARTHFEATURES_FEATURE_TILE_SOURCE_H
#define OSGEARTHFEATURES_FEATURE_TILE_SOURCE_H 1

#include <osgEarthFeatures/Common>
#include <osgEarthFeatures/FeatureSource>
#include <osgEarthSymbology/Style>
#include <osgEarth/TileSource>
#include <osgEarth/Map>
#include <osg/Node>
#include <osgDB/ReaderWriter>
#include <list>

namespace osgEarth { namespace Features
{
    using namespace osgEarth;
    using namespace osgEarth::Symbology;

    class OSGEARTHFEATURES_EXPORT FeatureTileSourceOptions : public TileSourceOptions
    {
    public: // serializable properties

        optional<FeatureSourceOptions>& featureOptions() { return _featureOptions; }
        const optional<FeatureSourceOptions>& featureOptions() const { return _featureOptions; }

        osg::ref_ptr<StyleSheet>& styles() { return _styles; }
        const osg::ref_ptr<StyleSheet>& styles() const { return _styles; }

        //TODO: deprecate in favor of convert filter
        optional<Geometry::Type>& geometryTypeOverride() { return _geomTypeOverride; }
        const optional<Geometry::Type>& geometryTypeOverride() const { return _geomTypeOverride; }

    public:
        osg::ref_ptr<FeatureSource>& featureSource() { return _featureSource; }
        const osg::ref_ptr<FeatureSource>& featureSource() const { return _featureSource; }

        FeatureTileSourceOptions( const ConfigOptions& rhs =ConfigOptions() );

    public:
        virtual Config getConfig() const;

    protected:
        virtual void mergeConfig( const Config& conf );

        optional<FeatureSourceOptions> _featureOptions;
        osg::ref_ptr<StyleSheet>       _styles;
        optional<Geometry::Type>       _geomTypeOverride;
        osg::ref_ptr<FeatureSource>    _featureSource;

    private:
        void fromConfig( const Config& conf );
    };


    class OSGEARTHFEATURES_EXPORT FeatureTileSource : public TileSource
    {
    public:      
        FeatureTileSource( const TileSourceOptions& options =TileSourceOptions() );

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

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

    public: // properties:

        FeatureSource* getFeatureSource() { return _features.get(); }

        void setFeatureSource( FeatureSource* source );

    protected:

        virtual osg::Referenced* createBuildData() {
            return NULL; }     

        virtual bool renderFeaturesForStyle(
            const Style&       style,
            const FeatureList& features,
            osg::Referenced*   buildData,
            const GeoExtent&   imageExtent,
            osg::Image*        out_image ) { return false; }            
            
        virtual bool preProcess(
            osg::Image* image,
            osg::Referenced* buildData ) { return true; }
            
        virtual bool postProcess(
            osg::Image* image,
            osg::Referenced* buildData ) { return true; }

    public:

        // META_Object specialization:
        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 FeatureTileSource*>(obj)!=NULL; }
        virtual const char* className() const { return "FeatureTileSource"; }
        virtual const char* libraryName() const { return "osgEarthFeatures"; }

    protected:

        virtual ~FeatureTileSource() { }

        osg::ref_ptr<FeatureSource> _features;
        const FeatureTileSourceOptions _options;
        //osg::ref_ptr<const FeatureTileSourceOptions> _options;
        osg::ref_ptr<const osgEarth::Map> _map;
        bool _initialized;
        
        bool queryAndRenderFeaturesForStyle(
            const Style&     style,
            const Query&     query,
            osg::Referenced* data,
            const GeoExtent& imageExtent,
            osg::Image*      out_image );
    };

    } } // namespace osgEarth::Features

#endif // OSGEARTHFEATURES_FEATURE_TILE_SOURCE_H