libosgearth-dev 2.4.0+dfsg-6 / usr / include / osgEarth / HeightFieldUtils

/* -*-c++-*- */
/* osgEarth - Dynamic map generation toolkit for OpenSceneGraph
* Copyright 2008-2013 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_HEIGHTFIELDUTILS_H
#define OSGEARTH_HEIGHTFIELDUTILS_H

#include <osgEarth/Common>
#include <osgEarth/GeoData>
#include <osg/Shape>
#include <osg/CoordinateSystemNode>
#include <osg/ClusterCullingCallback>
#include <osgTerrain/ValidDataOperator>

namespace osgEarth
{
    class OSGEARTH_EXPORT HeightFieldUtils
    {
    public:
        /**
         * Gets the interpolated height value at the specified fractional pixel position.
         */
        static float getHeightAtPixel(
            const osg::HeightField* hf, 
            double c, double r, 
            ElevationInterpolation interpoltion = INTERP_BILINEAR);
        
        /**
         * Gets the interpolated height value at the specific geolocation.
         */
        static float getHeightAtLocation(
            const osg::HeightField* hf, 
            double x, double y, 
            double llx, double lly,
            double dx, double dy,
            ElevationInterpolation interpolation = INTERP_BILINEAR);

        /**
         * Gets the interpolated elevation at the specified "normalized unit location".
         * i.e., nx => [0.0, 1.0], ny => [0.0, 1.0] where 0.0 and 1.0 are the opposing
         * endposts of the heightfield.
         */
        static float getHeightAtNormalizedLocation(
            const osg::HeightField* hf,
            double nx, double ny,
            ElevationInterpolation interp = INTERP_BILINEAR);

        /**
         * Scales all the height values in a heightfield from scalar units to "linear degrees".
         * The only purpose of this is to show reasonable height values in a projected
         * Plate Carre map (in which vertical units are not well defined).
         */
        static void scaleHeightFieldToDegrees( osg::HeightField* hf );
        
        /**
         * Creates a heightfield containing MSL heights for the specified extent.
         * If the SRS (in GeoExtent) has a vertical datum, the height values will be those of
         * its reference geoid. If there is no vertical datum, we assume that MSL == the reference
         * ellipsoid, and all the HF values will be zero.
         */
        static osg::HeightField* createReferenceHeightField( 
            const GeoExtent& ex, 
            unsigned         numCols,
            unsigned         numRows );

        /**
         * Subsamples a heightfield to the specified extent.
         */
        static osg::HeightField* createSubSample(
            osg::HeightField*      input, 
            const GeoExtent&       inputEx,
            const GeoExtent&       outputEx,
            ElevationInterpolation interpolation = INTERP_BILINEAR);

        /**
         * Resizes a heightfield, keeping the corner values the same and
         * resampling the internal posts.
         */
        static osg::HeightField* resampleHeightField(
            osg::HeightField* input,
            int newX,
            int newY,
            ElevationInterpolation interp = INTERP_BILINEAR );

        /**
         * Resolves any "invalid" height values in the hieghtfield, replacing them
         * with valid values from a Geoid (or zero if no geoid).
         */
        static void resolveInvalidHeights(
            osg::HeightField* grid,
            const GeoExtent&  extent,
            float             invalidValue,
            const Geoid*      geoid );
        
        /**
         * Creates a new cluster culler based on a heightfield.
         * Cluster cullers are for geocentric maps only, and therefore requires
         * the ellipsoid model.
         */
        static osg::NodeCallback* createClusterCullingCallback(
            osg::HeightField*    grid, 
            osg::EllipsoidModel* em, 
            float verticalScale =1.0f );
    };

    /**
    * A collection of ValidDataOperators.  All operators must pass to be considered valid.
    */
    struct OSGEARTH_EXPORT CompositeValidValueOperator : public osgTerrain::ValidDataOperator
    {
        typedef std::vector<osg::ref_ptr<osgTerrain::ValidDataOperator> > ValidDataOperatorList;
        ValidDataOperatorList& getOperators() { return _operators;}

        virtual bool operator() (float value) const
        {
            for (ValidDataOperatorList::const_iterator itr = _operators.begin(); itr != _operators.end(); ++itr)
            {
                if (!(*itr->get())(value)) return false;
            }
            return true;
        }

        ValidDataOperatorList _operators;
    };

    /**
     * Visitor that replaces "invalid" data values with a known value.
     */
    struct OSGEARTH_EXPORT ReplaceInvalidDataOperator : public osg::Referenced
    {
        ReplaceInvalidDataOperator();

        virtual void operator()(osg::HeightField* heightField);

        osgTerrain::ValidDataOperator* getValidDataOperator() { return _validDataOperator.get(); }
        void setValidDataOperator(osgTerrain::ValidDataOperator* validDataOperator) { _validDataOperator = validDataOperator; }

        float getReplaceWith() { return _replaceWith; }
        void setReplaceWith( float replaceWith ) { _replaceWith = replaceWith; }

        osg::ref_ptr<osgTerrain::ValidDataOperator> _validDataOperator;
        float _replaceWith;
    };

    /**
     * Visitor that replaces "invalid" data values with a default value.
     */
    struct OSGEARTH_EXPORT FillNoDataOperator : public osg::Referenced
    {
        FillNoDataOperator();

        virtual void operator()(osg::HeightField* heightField);

        osgTerrain::ValidDataOperator* getValidDataOperator() { return _validDataOperator.get(); }
        void setValidDataOperator(osgTerrain::ValidDataOperator* validDataOperator) { _validDataOperator = validDataOperator; }

        float getDefaultValue() { return _defaultValue; }
        void setDefaultValue(float defaultValue) { _defaultValue = defaultValue; }

        osg::ref_ptr<osgTerrain::ValidDataOperator> _validDataOperator;

        float _defaultValue;
    };
}

#endif //OSGEARTH_HEIGHTFIELDUTILS_H