This file is indexed.

/usr/include/osgEarth/ImageUtils is in libosgearth-dev 2.7.0+dfsg-2+b3.

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
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
/* -*-c++-*- */
/* osgEarth - Dynamic map generation toolkit for OpenSceneGraph
 * Copyright 2015 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_IMAGEUTILS_H
#define OSGEARTH_IMAGEUTILS_H

#include <osgEarth/Common>
#include <osg/Image>
#include <osg/Texture>
#include <osg/GL>
#include <vector>

//These formats were not added to OSG until after 2.8.3 so we need to define them to use them.
#ifndef GL_EXT_texture_compression_rgtc
  #define GL_COMPRESSED_RED_RGTC1_EXT                0x8DBB
  #define GL_COMPRESSED_SIGNED_RED_RGTC1_EXT         0x8DBC
  #define GL_COMPRESSED_RED_GREEN_RGTC2_EXT          0x8DBD
  #define GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT   0x8DBE
#endif

#ifndef GL_IMG_texture_compression_pvrtc
    #define GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG      0x8C00
    #define GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG      0x8C01
    #define GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG     0x8C02
    #define GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG     0x8C03
#endif

namespace osgEarth
{
    class OSGEARTH_EXPORT ImageUtils
    {
    public:
        /**
         * Clones an image.
         *
         * Use this instead of the osg::Image copy construtor, which keeps the referenced to
         * its underlying BufferObject around. Calling dirty() on the new clone appears to
         * help, but just call this method instead to be sure.
         */
        static osg::Image* cloneImage( const osg::Image* image );

        /**
         * Tweaks an image for consistency. OpenGL allows enums like "GL_RGBA" et.al. to be
         * used in the internal texture format, when really "GL_RGBA8" is the proper things
         * to use. This method accounts for that. Some parts of osgEarth (like the texture-
         * array compositor) rely on the internal texture format being correct.
         * (http://http.download.nvidia.com/developer/Papers/2005/Fast_Texture_Transfers/Fast_Texture_Transfers.pdf)
         */
        static void fixInternalFormat(osg::Image* image);

        /**
         * Marks an image as containing un-normalized data values.
         *
         * Normally the values in an image are "normalized", i.e. scaled so they are in the
         * range [0..1]. This is normal for color values. But when the image is being used
         * for coverage data (a value lookup table) it is desireable to store the raw 
         * values instead.
         */
        static void markAsUnNormalized(osg::Image* image, bool value);

        /** Inverse of above. */
        static void markAsNormalized(osg::Image* image, bool value) { markAsUnNormalized(image, !value); }

        /**
         * Whether the image has been marked as containing un-normalized values.
         */
        static bool isUnNormalized(const osg::Image* image);

        /**
         * Whether the image has been marked as containing normalized values.
         */
        static bool isNormalized(const osg::Image* image) { return !isUnNormalized(image); }

        /**
         * Copys a portion of one image into another.
         */
        static bool copyAsSubImage(
            const osg::Image* src, 
            osg::Image*       dst, 
            int dst_start_col, int dst_start_row);

        /**
         * Resizes an image. Returns a new image, leaving the input image unaltered.
         *
         * Note. If the output parameter is NULL, this method will allocate a new image and
         * resize into that new image. If the output parameter is non-NULL, this method will
         * assume that the output image is already allocated to the proper size, and will
         * do a resize+copy into that image. In the latter case, it is your responsibility
         * to make sure the output image is allocated to the proper size.
         *
         * If the output parameter is non-NULL, then the mipmapLevel is also considered.
         * This lets you resize directly into a particular mipmap level of the output image.
         */
        static bool resizeImage(
            const osg::Image* input, 
            unsigned int new_s, unsigned int new_t,
            osg::ref_ptr<osg::Image>& output,
            unsigned int mipmapLevel =0, bool bilinear=true );

        /**
         * Crops the input image to the dimensions provided and returns a
         * new image. Returns a new image, leaving the input image unaltered.
         * Note:  The input destination bounds are modified to reflect the bounds of the
         *        actual output image.  Due to the fact that you cannot crop in the middle of a pixel
         *        The specified destination extents and the output extents may vary slightly.
         *@param src_minx
         *       The minimum x coordinate of the input image.
         *@param src_miny
         *       The minimum y coordinate of the input image.
         *@param src_maxx
         *       The maximum x coordinate of the input image.
         *@param src_maxy
         *       The maximum y coordinate of the input image.
         *@param dst_minx
         *       The desired minimum x coordinate of the cropped image.
         *@param dst_miny
         *       The desired minimum y coordinate of the cropped image.
         *@param dst_maxx
         *       The desired maximum x coordinate of the cropped image.
         *@param dst_maxy
         *       The desired maximum y coordinate of the cropped image.
         */
        static osg::Image* cropImage(
            const osg::Image* image,
            double src_minx, double src_miny, double src_maxx, double src_maxy,
            double &dst_minx, double &dst_miny, double &dst_maxx, double &dst_maxy);

        /**
         * Creates an Image that "blends" two images into a new image in which "primary"
         * occupies mipmap level 0, and "secondary" occupies all the other mipmap levels.
         *
         * WARNING: this method assumes that primary and seconday are the same exact size
         * and the same exact format.
         */
        static osg::Image* createMipmapBlendedImage(
            const osg::Image* primary,
            const osg::Image* secondary );
        
        /**
         * Creates a new image containing mipmaps built with nearest-neighbor
         * sampling.
         */
        static osg::Image* buildNearestNeighborMipmaps(
            const osg::Image* image);

        /**
         * Blends the "src" image into the "dest" image, based on the "a" value.
         * The two images must be the same.
         */
        static bool mix( osg::Image* dest, const osg::Image* src, float a );

        /**
         * Creates and returns a copy of the input image after applying a
         * sharpening filter. Returns a new image, leaving the input image unaltered.
         */
        static osg::Image* createSharpenedImage( const osg::Image* image );

        /**
         * For each "layer" in the input image (each bitmap in the "r" dimension),
         * create a new, separate image with r=1. If the input image is r=1, it is
         * simply placed onto the output vector (no copy).
         * Returns true upon sucess, false upon failure
         */
        static bool flattenImage(osg::Image* image, std::vector<osg::ref_ptr<osg::Image> >& output);

        /**
         * Gets whether the input image's dimensions are powers of 2.
         */
        static bool isPowerOfTwo(const osg::Image* image);

        /**
         * Gets a transparent, single pixel image used for a placeholder
         */
        static osg::Image* createEmptyImage();

        /**
         * Gets a transparent image used for a placeholder with the specified dimensions
         */
        static osg::Image* createEmptyImage(unsigned int s, unsigned int t);

        /**
         * Creates a one-pixel image.
         */
        static osg::Image* createOnePixelImage(const osg::Vec4& color);

        /**
         * Tests an image to see whether it's "empty", i.e. completely transparent,
         * within an alpha threshold.
         */
        static bool isEmptyImage(const osg::Image* image, float alphaThreshold =0.01);

        /**
         * Tests an image to see whether it's "single color", i.e. completely filled with a single color,
         * within an threshold (threshold is tested on each channel).
         */
        static bool isSingleColorImage(const osg::Image* image, float threshold =0.01);

        /**
         * Returns true if it is possible to convert the image to the specified 
         * format/datatype specification.
         */
        static bool canConvert(const osg::Image* image, GLenum pixelFormat, GLenum dataType);

        /**
         * Converts an image to the specified format.
         */
        static osg::Image* convert(const osg::Image* image, GLenum pixelFormat, GLenum dataType);

        /**
         *Converts the given image to RGB8
         */
        static osg::Image* convertToRGB8(const osg::Image* image);

        /**
         *Converts the given image to RGBA8
         */
        static osg::Image* convertToRGBA8(const osg::Image* image);

        /**
         * True if the two images are of the same format (pixel format, data type, etc.)
         * though not necessarily the same size, depth, etc.
         */
        static bool sameFormat(const osg::Image* lhs, const osg::Image* rhs);

        /**
         * True if the two images have the same format AND size, and can therefore
         * be used together in a texture array.
         */
        static bool textureArrayCompatible(const osg::Image* lhs, const osg::Image* rhs);

        /**
         *Compares the image data of two images and determines if they are equivalent
         */
        static bool areEquivalent(const osg::Image *lhs, const osg::Image *rhs);

        /**
         * Whether two colors are roughly equivalent.
         */
        static bool areRGBEquivalent( const osg::Vec4& lhs, const osg::Vec4& rhs, float epsilon =0.01f ) {
            return
                fabs(lhs.r() - rhs.r()) < epsilon &&
                fabs(lhs.g() - rhs.g()) < epsilon &&
                fabs(lhs.b() - rhs.b()) < epsilon;
        }

        /**
         * Checks whether the image has an alpha component 
         */
        static bool hasAlphaChannel( const osg::Image* image );

        /**
         * Checks whether an image has transparency; i.e. whether
         * there are any pixels with an alpha component whole value
         * falls below the specified threshold.
         */
        static bool hasTransparency(const osg::Image* image, float alphaThreshold =1.0f);

        /**
         * Finds pixels with alpha less than [maxAlpha] and sets their color
         * to match that or neighboring non-alpha pixels. This facilitates multipass
         * blending or abutting tiles by overlapping them slightly. Specify "maxAlpha"
         * as the maximum value to consider when searching for fully-transparent pixels.
         *
         * Returns false if there is no reader or writer for the image's format.
         */
        static bool featherAlphaRegions(osg::Image* image, float maxAlpha =0.0f);

        /**
         * Converts an image (in place) to premultiplied-alpha format.
         * Returns False is the conversion fails, e.g., if there is no reader
         * or writer for the image format.
         */
        static bool convertToPremultipliedAlpha(osg::Image* image);

        /**
         * Checks whether the given image is compressed
         */
        static bool isCompressed( const osg::Image* image );

        /**
         * Generated a bump map image for the input image
         */
        static osg::Image* createBumpMap( const osg::Image* input );

        /**
         * Is it a floating-point texture format?
         */
        static bool isFloatingPointInternalFormat( GLint internalFormat );

        /**
         * Compute a texture compression format suitable for the image.
         */
        static bool computeTextureCompressionMode(
            const osg::Image* image,
            osg::Texture::InternalFormatMode& out_mode);

        /**
         * 
         */
        static osg::Image* upSampleNN(const osg::Image* src, int quadrant);

        /**
         * Reads color data out of an image, regardles of its internal pixel format.
         */
        class OSGEARTH_EXPORT PixelReader
        {
        public:
            /**
             * Constructs a pixel reader. "Normalized" means that the values in the source
             * image have been scaled to [0..1] and should be denormalized upon reading.
             */
            PixelReader(const osg::Image* image);

            /** Whether PixelReader supports a given format/datatype combiniation. */
            static bool supports( GLenum pixelFormat, GLenum dataType );

            /** Whether PixelReader can read from the specified image. */
            static bool supports( const osg::Image* image ) {
                return image && supports(image->getPixelFormat(), image->getDataType() );
            }

            /** Reads a color from the image */
            osg::Vec4 operator()(int s, int t, int r=0, int m=0) const {
                return (*_reader)(this, s, t, r, m);
            }

            /** Reads a color from the image */
            osg::Vec4 operator()(unsigned s, unsigned t, unsigned r=0, int m=0) const {
                return (*_reader)(this, s, t, r, m);
            }

            /** Reads a color from the image by unit coords [0..1] */
            osg::Vec4 operator()(float s, float t, int r=0, int m=0) const {
                return (*_reader)(this,
                    (int)(s * (float)(_image->s()-1)),
                    (int)(t * (float)(_image->t()-1)),
                    r, m);
            }

            // internals:
            const unsigned char* data(int s=0, int t=0, int r=0, int m=0) const {
                return m == 0 ?
                    _image->data() + s*_colMult + t*_rowMult + r*_imageSize :
                    _image->getMipmapData(m) + s*_colMult + t*(_rowMult >> m) + r*(_imageSize>>m) ;
            }

            typedef osg::Vec4 (*ReaderFunc)(const PixelReader* ia, int s, int t, int r, int m);
            ReaderFunc _reader;
            const osg::Image* _image;
            unsigned _colMult;
            unsigned _rowMult;
            unsigned _imageSize;
            bool     _normalized;
        };
        
        /**
         * Writes color data to an image, regardles of its internal pixel format.
         */
        class OSGEARTH_EXPORT PixelWriter
        {
        public:
            /**
             * Constructs a pixel writer. "Normalized" means the values are scaled to [0..1]
             * before writing.
             */
            PixelWriter(osg::Image* image);

            /** Whether PixelWriter can write to an image with the given format/datatype combo. */
            static bool supports( GLenum pixelFormat, GLenum dataType );

            /** Whether PixelWriter can write to non-const version of an image. */
            static bool supports( const osg::Image* image ) {
                return image && supports(image->getPixelFormat(), image->getDataType() );
            }

            /** Writes a color to a pixel. */
            void operator()(const osg::Vec4& c, int s, int t, int r=0, int m=0) {
                (*_writer)(this, c, s, t, r, m );
            }

            void f(const osg::Vec4& c, float s, float t, int r=0, int m=0) {
                this->operator()( c,
                    (int)(s * (float)(_image->s()-1)),
                    (int)(t * (float)(_image->t()-1)),
                    r, m);
            }

            // internals:
            osg::Image* _image;
            unsigned _colMult;
            unsigned _rowMult;
            unsigned _imageSize;
            bool     _normalized;

            unsigned char* data(int s=0, int t=0, int r=0, int m=0) const {
                return m == 0 ?
                    _image->data() + s*_colMult + t*_rowMult + r*_imageSize :
                    _image->getMipmapData(m) + s*_colMult + t*(_rowMult >> m) + r*(_imageSize>>m);
            }

            typedef void (*WriterFunc)(const PixelWriter* iw, const osg::Vec4& c, int s, int t, int r, int m);
            WriterFunc _writer;
        };

        /**
         * Functor that visits every pixel in an image
         */
        template<typename T>
        struct PixelVisitor : public T
        {
            /**
             * Traverse an image, and call this method on the superclass:
             *
             *   bool operator(osg::Vec4& pixel);
             *
             * If that method returns true, write the value back at the same location.
             */
            void accept( osg::Image* image ) {
                PixelReader _reader( image );
                PixelWriter _writer( image );
                for( int r=0; r<image->r(); ++r ) {
                    for( int t=0; t<image->t(); ++t ) {
                        for( int s=0; s<image->s(); ++s ) {
                            osg::Vec4f pixel = _reader(s,t,r);
                            if ( (*this)(pixel) )
                                _writer(pixel,s,t,r);
                        }
                    }
                }
            }          

            /**
             * Traverse an image, and call this method on the superclass:
             *
             *   bool operator(const osg::Vec4& srcPixel, osg::Vec4& destPixel);
             *
             * If that method returns true, write destPixel back at the same location
             * in the destination image.
             */
            void accept( const osg::Image* src, osg::Image* dest ) {
                PixelReader _readerSrc( src );
                PixelReader _readerDest( dest );
                PixelWriter _writerDest( dest );
                for( int r=0; r<src->r(); ++r ) {
                    for( int t=0; t<src->t(); ++t ) {
                        for( int s=0; s<src->s(); ++s ) {
                            const osg::Vec4f pixelSrc = _readerSrc(s,t,r);
                            osg::Vec4f pixelDest = _readerDest(s,t,r);
                            if ( (*this)(pixelSrc, pixelDest) )
                                _writerDest(pixelDest,s,t,r);
                        }
                    }
                }
            }
        };

        /**
         * Simple functor to copy pixels from one image to another.
         *
         * Usage:
         *    PixelVisitor<CopyImage>().accept( fromImage, toImage );
         */
        struct CopyImage {
            bool operator()( const osg::Vec4f& src, osg::Vec4f& dest ) {
                dest = src;
                return true;
            }
        };
    };
}

#endif //OSGEARTH_IMAGEUTILS_H