This file is indexed.

/usr/include/osgEarth/MapOptions is in libosgearth-dev 2.4.0+dfsg-6.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
/* -*-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_MAP_OPTIONS_H
#define OSGEARTH_MAP_OPTIONS_H 1

#include <osgEarth/Common>
#include <osgEarth/Config>
#include <osgEarth/Cache>
#include <osgEarth/CachePolicy>
#include <osgEarth/GeoCommon>
#include <osgEarth/Profile>
#include <osgEarth/TerrainOptions>

namespace osgEarth
{
    /**
     * Configuration for a runtime map.
     */
    class OSGEARTH_EXPORT MapOptions : public ConfigOptions // no export (header-only)
    {
    public:
        enum CoordinateSystemType
        {
            CSTYPE_GEOCENTRIC,
            CSTYPE_GEOCENTRIC_CUBE,
            CSTYPE_PROJECTED
        };		

    public:
        MapOptions( const ConfigOptions& options =ConfigOptions() )
            : ConfigOptions          ( options ),
              _cachePolicy           ( ),
              _cstype                ( CSTYPE_GEOCENTRIC ),
              _referenceURI          ( "" ),
              _elevationInterpolation( INTERP_BILINEAR ),
              _elevTileSize          ( 8 )
        {
            fromConfig(_conf);
        }

        /** dtor */
        virtual ~MapOptions() { }

        /**
         * Human-readable name of the map.
         */
        optional<std::string>& name() { return _name; }
        const optional<std::string>& name() const { return _name; }

        /**
         * The coordinate system type of the map (default is CSTYPE_GEOCENTRIC)
         */
        optional<CoordinateSystemType>& coordSysType() { return _cstype; }
        const optional<CoordinateSystemType>& coordSysType() const { return _cstype; }

        /**
         * An explicit master profile for the Map. Usually this is calculated automatically,
         * but in some cases you need to set it manually.
         */
        optional<ProfileOptions>& profile() { return _profileOptions; }
        const optional<ProfileOptions>& profile() const { return _profileOptions; }

        /**
         * Caching setup for the entire map. By default, map layers added to the map will
         * inherit this setup unless they override or customize it with their own settings.
         */
        optional<CacheOptions>& cache() { return _cacheOptions; }
        const optional<CacheOptions>& cache() const { return _cacheOptions; }

        /**
         * Default cache policy that propagates to each layer.
         */
        optional<CachePolicy>& cachePolicy() { return _cachePolicy; }
        const optional<CachePolicy>& cachePolicy() const { return _cachePolicy; }

         /**
         * The interpolation method to use when sampling heightfields.
         */
        optional<ElevationInterpolation>& elevationInterpolation(void) { return _elevationInterpolation; }
        const optional<ElevationInterpolation>& elevationInterpolation(void) const { return _elevationInterpolation;}

        /**
         * Dimension of elevation tiles. By default, the engine will return 
         * elevation tiles sized to the largest available source tile. This forces
         * a set size.
         */
        optional<unsigned>& elevationTileSize() { return _elevTileSize; }
        const optional<unsigned>& elevationTileSize() const { return _elevTileSize; }

    public:
        /**
         * A reference location that drivers can use to load data from relative locations.
         * NOTE: this is a runtime-only property and is NOT serialized in the ConfigOptions.
         */
        optional<std::string>& referenceURI() { return _referenceURI; }
        const optional<std::string>& referenceURI() const { return _referenceURI; }
    
    public:
        Config getConfig() const;

        void mergeConfig( const Config& conf ) {
            ConfigOptions::mergeConfig( conf );
            fromConfig( conf );
        }

    private:
        void fromConfig( const Config& conf );

        optional<std::string>            _name;
        optional<ProfileOptions>         _profileOptions;
        optional<CacheOptions>           _cacheOptions;
        optional<CachePolicy>            _cachePolicy;
        optional<CoordinateSystemType>   _cstype;
        optional<std::string>            _referenceURI;
        optional<ElevationInterpolation> _elevationInterpolation;
        optional<unsigned>               _elevTileSize;
    };
}

#endif // OSGEARTH_MAP_ENGINE_PROPERTIES_H