/home/cube/sources/osgearth/src/osgEarth/GeoData

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_GEODATA_H
#define OSGEARTH_GEODATA_H 1

#include <osg/Referenced>
#include <osg/Image>
#include <osg/Shape>
#include <osgTerrain/Locator>
#include <osgEarth/Common>
#include <osgEarth/SpatialReference>
#include <osgEarth/VerticalSpatialReference>
#include <osgEarth/HeightFieldUtils>
#include <osgEarth/Units>

namespace osgEarth
{
    class OSGEARTH_EXPORT Bounds : public osg::BoundingBoxImpl<osg::Vec3d>
    {
    public:
        Bounds();
        Bounds(double xmin, double ymin, double xmax, double ymax );

        double width() const;
        double height() const;
        double depth() const;
        bool contains(double x, double y ) const;
        bool contains(const Bounds& rhs) const;
        Bounds unionWith(const Bounds& rhs) const; 
        Bounds intersectionWith(const Bounds& rhs) const;
        void expandBy( double x, double y );
        void expandBy( double x, double y, double z );
        void expandBy( const Bounds& rhs );
        osg::Vec2d center2d() const;
        double radius2d() const;
        std::string toString() const;
        bool isValid() const;
        bool isEmpty() const { return !isValid(); }
        void transform( const SpatialReference* fromSRS, const SpatialReference* toSRS );
    };

    class OSGEARTH_EXPORT GeoExtent
    {
    public:
        GeoExtent(); 

        GeoExtent(
            const SpatialReference* srs,
            double xmin = FLT_MAX, double ymin = FLT_MAX,
            double xmax = -FLT_MAX, double ymax = -FLT_MAX );

        GeoExtent( const GeoExtent& rhs );

        GeoExtent( const SpatialReference* srs, const Bounds& bounds );

        bool operator == ( const GeoExtent& rhs ) const;
        bool operator != ( const GeoExtent& rhs ) const;

        const SpatialReference* getSRS() const;

        double xMin() const { return _xmin; }
        double& xMin() { return _xmin; }
        double yMin() const { return _ymin; }
        double& yMin() { return _ymin; }
        double xMax() const { return _xmax; }
        double& xMax() { return _xmax; }
        double yMax() const { return _ymax; }
        double& yMax() { return _ymax; }

        double width() const;
        double height() const;

        void getCentroid( double& out_x, double& out_y ) const;

        bool crossesDateLine() const;

        void getBounds(double &xmin, double &ymin, double &xmax, double &ymax) const;

        bool isValid() const;
        bool defined() const { return isValid(); }

        bool splitAcrossDateLine( GeoExtent& first, GeoExtent& second ) const;

        GeoExtent transform( const SpatialReference* to_srs ) const;

        bool contains(double x, double y, const SpatialReference* xy_srs =0L) const;

        bool contains( const Bounds& rhs ) const;

        bool intersects( const GeoExtent& rhs ) const;

        Bounds bounds() const;

        void expandToInclude( double x, double y );

        void expandToInclude( const Bounds& rhs );
        
        GeoExtent intersectionSameSRS( const Bounds& rhs ) const;

        std::string toString() const;

        void scale(double x_scale, double y_scale);

                void expand( double x, double y );

        double area() const;

    public:
        static GeoExtent INVALID;

    private:
        osg::ref_ptr<const SpatialReference> _srs;
        double _xmin, _ymin, _xmax, _ymax;
    };

    class OSGEARTH_EXPORT DataExtent : public GeoExtent
    {
    public:
        DataExtent(const GeoExtent& extent, unsigned int minLevel, unsigned int maxLevel);

        unsigned int getMinLevel() const;

        unsigned int getMaxLevel() const;

    private:
        unsigned int _minLevel;
        unsigned int _maxLevel;
    };

    typedef std::vector< DataExtent > DataExtentList;


    class OSGEARTH_EXPORT GeoImage
    {
    public:
        GeoImage();

        GeoImage( osg::Image* image, const GeoExtent& extent );

        static GeoImage INVALID;

    public:
        bool valid() const { return _image.valid(); }

        osg::Image* getImage() const;

        const GeoExtent& getExtent() const;

        const SpatialReference* getSRS() const;

        GeoImage crop( 
            const GeoExtent& extent,
            bool exact = false,
            unsigned int width = 0,
            unsigned int height = 0) const;

        GeoImage reproject(
            const SpatialReference* to_srs,
            const GeoExtent* to_extent = 0,
            unsigned int width = 0,
            unsigned int height = 0) const;

        GeoImage addTransparentBorder(
            bool leftBorder=true, 
            bool rightBorder=true, 
            bool bottomBorder=true, 
            bool topBorder=true);

        osg::Image* takeImage();

                double getUnitsPerPixel() const;

    private:
        osg::ref_ptr<osg::Image> _image;
        GeoExtent _extent;
    };

    typedef std::vector<GeoImage> GeoImageVector;

    class OSGEARTH_EXPORT GeoHeightField
    {
    public:
        GeoHeightField();

        GeoHeightField(
            osg::HeightField* heightField,
            const GeoExtent& extent,
            const VerticalSpatialReference* vsrs);

        static GeoHeightField INVALID;

        bool valid() const { return _heightField.valid(); }

        bool getElevation(
            const SpatialReference* inputSRS, 
            double x, double y,
            ElevationInterpolation interp,
            const VerticalSpatialReference* outputVSRS,
            float& out_elevation ) const;
        
        GeoHeightField createSubSample( const GeoExtent& destEx, ElevationInterpolation interpolation) const;

        const GeoExtent& getExtent() const;

        const osg::HeightField* getHeightField() const;
        osg::HeightField* getHeightField();

        osg::HeightField* takeHeightField();

    protected:
        osg::ref_ptr<osg::HeightField> _heightField;
        GeoExtent _extent;
        osg::ref_ptr<const VerticalSpatialReference> _vsrs;
    };

        typedef std::vector<GeoHeightField> GeoHeightFieldVector;

    
    class OSGEARTH_EXPORT Geoid : public osg::Referenced
    {
    public:
        Geoid();

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

        void setHeightField( const GeoHeightField& hf );

        float getOffset(
            double lat_deg, double lon_deg, 
            const ElevationInterpolation& interp =INTERP_BILINEAR) const;

        const Units& getUnits() const { return _units; }
        void setUnits( const Units& value );

        bool isValid() const { return _valid; }

        bool isEquivalentTo( const Geoid& rhs ) const;

    private:
        std::string _name;
        GeoHeightField _hf;
        Units _units;
        bool _valid;
        void validate();
    };

}

#endif // OSGEARTH_GEODATA_H