This file is indexed.

/usr/include/osgEarth/Map 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
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
/* -*-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_H
#define OSGEARTH_MAP_H 1

#include <osgEarth/Common>
#include <osgEarth/GeoData>
#include <osgEarth/Profile>
#include <osgEarth/MapOptions>
#include <osgEarth/MapCallback>
#include <osgEarth/ImageLayer>
#include <osgEarth/ElevationLayer>
#include <osgEarth/ModelLayer>
#include <osgEarth/MaskLayer>
#include <osgEarth/Revisioning>
#include <osgEarth/ThreadingUtils>
#include <osgDB/ReaderWriter>

namespace osgEarth
{
    class MapInfo;

    /**
     * Map is the main data model that the MapNode will render. It is a
     * container for all Layer objects (that contain the actual data) and
     * the rendering options.
     */
    class OSGEARTH_EXPORT Map : public osg::Referenced
    {
    public:
        /**
         * Constructs a new, empty map.
         */
        Map( const MapOptions& options =MapOptions() );

    public:
        /**
         * Gets the options governing this map.
         */
        const MapOptions& getMapOptions() const { return _mapOptions; }

        /**
         * Gets the options with which this map was initially created.
         */
        const MapOptions& getInitialMapOptions() const { return _initMapOptions; }

        /**
         * Gets the map's master profile. This value may not be available until 
         * after autoCalculateProfile has been called.
         */
        const Profile* getProfile() const;

        /**
         * Gets the SRS of the map's profile (convenience)
         */
        const SpatialReference* getSRS() const { return _profile.valid() ? _profile->getSRS() : 0L; }

        /**
         * Copies references of the map image layers into the output list.
         * This method is thread safe. It returns the map revision that was
         * in effect when the data was copied.
         */
        Revision getImageLayers( ImageLayerVector& out_layers ) const;

        /**
         * Gets the number of image layers in the map.
         */
        int getNumImageLayers() const;

        /**
         * Gets an image layer by name.
         */
        ImageLayer* getImageLayerByName( const std::string& name ) const;

        /**
         * Gets an image layer by its unique ID.
         */
        ImageLayer* getImageLayerByUID( UID layerUID ) const;

        /**
         * Gets an image layer at the specified index.
         */
        ImageLayer* getImageLayerAt( int index ) const;

        /**
         * Copies references of the elevation layers into the output list.
         * This method is thread safe. It returns the map revision that was
         * in effect when the data was copied.
         */
        Revision getElevationLayers( ElevationLayerVector& out_layers ) const;

        /**
         * Gets the number of elevation layers in the map.
         */
        int getNumElevationLayers() const;

        /**
         * Gets an elevation layer by name.
         */
        ElevationLayer* getElevationLayerByName( const std::string& name ) const;

        /**
         * Gets an elevation layer by its unique ID.
         */
        ElevationLayer* getElevationLayerByUID( UID layerUID ) const;

        /**
         * Gets an elevation layer at the specified index.
         */
        ElevationLayer* getElevationLayerAt( int index ) const;

        /** 
         * Copies references of the model layers into the output list.
         * This method is thread safe. It returns the map revision that was
         * in effect when the data was copied.
         */
        Revision getModelLayers( ModelLayerVector& out_layers ) const;

        /**
         * Gets the number of model layers in the map.
         */
        int getNumModelLayers() const;

        /**
         * Gets a model layer by name.
         */
        ModelLayer* getModelLayerByName( const std::string& name ) const;

        /**
         * Gets a model layer by its unique ID.
         */
        ModelLayer* getModelLayerByUID( UID layerUID ) const;

        /**
         * Gets the model layer at the specified index.
         */
        ModelLayer* getModelLayerAt( int index ) const;

        /**
         * Copies references of the mask layers into the output list.
         * This method is thread safe. It returns the map revision that was
         * in effect when the data was copied.
         */
        int getTerrainMaskLayers( MaskLayerVector& out_list ) const;

        /**
         * Adds a map layer callback to this map. This will be notified whenever layers are
         * added, removed, or re-ordered.
         */
        void addMapCallback( MapCallback* callback ) const;

        /**
         * Removes a callback previously added with addMapCallback.
         */
        void removeMapCallback( MapCallback* callback );

        /**
         * Begin a batch-update operation. Call this if you intend to add multiple
         * layers at once; then call endUpdate() to complete the operation.
         * Between calls to beginUpdate() and endUpdate(), Map will not invoke
         * any callbacks you added wtih addMapCallback.
         */
        void beginUpdate();

        /**
         * Complete a batch update operation that started with a call to
         * beginUpdate(). Fires all callbacks for operations that occurred
         * since the call to beginUpdate().
         */
        void endUpdate();

        /**
         * Adds an image layer to the map.
         */
        void addImageLayer( ImageLayer* layer );

        /**
        * Adds an image layer to the map at the specified index.
        */
        void insertImageLayer( ImageLayer* layer, unsigned int index );

        /**
         * Removes an image layer from the map.
         */
        void removeImageLayer( ImageLayer* layer );

        /**
         * Moves (re-orders) an image layer to another index position in its list.
         */
        void moveImageLayer( ImageLayer* layer, unsigned int newIndex );

        /**
         * Adds an elevation layer to the map.
         */
        void addElevationLayer( ElevationLayer* layer );

        /**
         * Removes an elevation layer from the map.
         */
        void removeElevationLayer( ElevationLayer* layer );

        /**
         * Moves (re-orders) an elevation layer to another index position in its list.
         */
        void moveElevationLayer( ElevationLayer* layer, unsigned int newIndex );

        /**
         * Adds a new model layer to the map.
         */
        void addModelLayer( ModelLayer* layer );

        /**
         * Adds a new model layer to the map at the specified index.
         */
        void insertModelLayer( ModelLayer* layer, unsigned int index );

        /**
         * Removes a model layer from the map.
         */
        void removeModelLayer( ModelLayer* layer );

        /**
         * Moves (re-orders) an image layer to another index position in its list.
         */
        void moveModelLayer( ModelLayer* layer, unsigned int newIndex );

        /**
         * Adds a new layer to use as a terrain mask.
         */
        void addTerrainMaskLayer( MaskLayer* layer );

        /**
         * Removed a terrain mask layer that was set with setTerrainMaskLayer().
         */
        void removeTerrainMaskLayer( MaskLayer* layer );

        /**
         * Clear all layers from this map.
         */
        void clear();

        /**
         * Replaces the layers in this Map with layers from the specified Map
         * (except for terrain mask layers)
         */
        void setLayersFromMap( const Map* map );

    public:
        /**
         * Gets the user-provided options structure stored in this map.
         */
        const osgDB::ReaderWriter::Options* getGlobalOptions() const;
        void setGlobalOptions( const osgDB::ReaderWriter::Options* options );

        /**
         * Sets the readable name of this map.
         */
        void setName( const std::string& name );

        /** 
         * Gets the readable name of this map.
         */
        const std::string& getName() const { return _name; }

        /**
         * Creates a heightfield for the region covered by the given TileKey, falling back on
         * lower resolutions if necessary.
         *
         * NOTE: By default, this method will return a heightfield with HAE (height above ellipsoid) 
         * values, even if the TileKey profile has an MSL vertical datum. That's because this 
         * method is usually called to produce a renderable height field. You can override this
         * behavior by passing in convertToHAE=false.
         *
         * @param key
         *      Tile key defining the region (and ideal LOD) for which to return a heightfield
         * @param fallbackIfNecessary
         *      If the map can't generate a true heightfield for the key, fall back on lower
         *      levels of detail until it can make one.
         * @param out_hf
         *      Resulting heightfield is written here.
         * @param out_isFallback
         *      Output flag telling the caller whether the method had to "fall back" on a 
         *      lower level of detail.
         * @param convertToHAE
         *      Whether to return height-above-ellipsoid values in the heightfield, even if the
         *      input tile key's SRS specifies a vertical datum (which would normally result in
         *      a heightfield expressed relative to MSL). This is typical for when you are building
         *      the actual 3D terrain.
         * @param samplePolicy
         *      How to intepolate heightfield samples.
         * @param progress
         *      (optional) progress callback.
         */
        bool getHeightField(
            const TileKey&                  key,
            bool                            fallbackIfNeessary,
            osg::ref_ptr<osg::HeightField>& out_hf,
            bool*                           out_isFallback =0L,            
            bool                            convertToHAE   =true,
            ElevationSamplePolicy           samplePolicy   =SAMPLE_FIRST_VALID,
            ProgressCallback*               progress       =0L)  const;

        /**
         * Sets the Cache for this Map. Set to NULL for no cache.
         */
        void setCache( Cache* cache );

        /**
         * Gets the Cache for this Map
         */
        Cache* getCache() const;

        /**
         * Gets the revision # of the map. The revision # changes every time
         * you add, remove, or move layers. You can use this to track changes
         * in the map model (as a alternative to installing a MapCallback).
         */
        Revision getDataModelRevision() const;

        /**
         * Convenience function that returns TRUE if the map cs type is
         * geocentric.
         */
        bool isGeocentric() const;

        /**
         * Synronizes a map frame to the current revision of the map's data model.
         * Returns true if new Map model data was available and a sync occurred;
         * returns false if nothing changed.
         */    
        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
        };

        /**
         * Gets the database options associated with this map.
         */
        const osgDB::Options* getDBOptions() const { return _dbOptions.get(); }

        const Profile* getProfileNoVDatum() const { return _profileNoVDatum.get(); }

    protected:

        virtual ~Map();

    private:

        MapOptions _mapOptions;
        const MapOptions _initMapOptions;
        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<const Profile> _profileNoVDatum;
        osg::ref_ptr<Cache> _cache;
        Revision _dataModelRevision;
        osg::ref_ptr<osgDB::Options> _dbOptions;

    private:
        void calculateProfile();

        friend class MapInfo;
    };
}

#endif // OSGEARTH_MAP_H