GDAL
vrtdataset.h
1 /******************************************************************************
2  * $Id: vrtdataset.h 56578e74c2851abf597312e07504cfe639cceedd 2018-04-24 20:38:09 +0200 Even Rouault $
3  *
4  * Project: Virtual GDAL Datasets
5  * Purpose: Declaration of virtual gdal dataset classes.
6  * Author: Frank Warmerdam, warmerdam@pobox.com
7  *
8  ******************************************************************************
9  * Copyright (c) 2001, Frank Warmerdam <warmerdam@pobox.com>
10  * Copyright (c) 2007-2013, Even Rouault <even dot rouault at mines-paris dot org>
11  *
12  * Permission is hereby granted, free of charge, to any person obtaining a
13  * copy of this software and associated documentation files (the "Software"),
14  * to deal in the Software without restriction, including without limitation
15  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
16  * and/or sell copies of the Software, and to permit persons to whom the
17  * Software is furnished to do so, subject to the following conditions:
18  *
19  * The above copyright notice and this permission notice shall be included
20  * in all copies or substantial portions of the Software.
21  *
22  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
23  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
24  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
25  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
26  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
27  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
28  * DEALINGS IN THE SOFTWARE.
29  ****************************************************************************/
30 
31 #ifndef VIRTUALDATASET_H_INCLUDED
32 #define VIRTUALDATASET_H_INCLUDED
33 
34 #ifndef DOXYGEN_SKIP
35 
36 #include "cpl_hash_set.h"
37 #include "gdal_pam.h"
38 #include "gdal_priv.h"
39 #include "gdal_rat.h"
40 #include "gdal_vrt.h"
41 
42 #include <map>
43 #include <memory>
44 #include <vector>
45 
46 int VRTApplyMetadata( CPLXMLNode *, GDALMajorObject * );
47 CPLXMLNode *VRTSerializeMetadata( GDALMajorObject * );
48 CPLErr GDALRegisterDefaultPixelFunc();
49 
50 #if 0
51 int VRTWarpedOverviewTransform( void *pTransformArg, int bDstToSrc,
52  int nPointCount,
53  double *padfX, double *padfY, double *padfZ,
54  int *panSuccess );
55 void* VRTDeserializeWarpedOverviewTransformer( CPLXMLNode *psTree );
56 #endif
57 
58 /************************************************************************/
59 /* VRTOverviewInfo() */
60 /************************************************************************/
61 class VRTOverviewInfo
62 {
63 public:
64  CPLString osFilename;
65  int nBand;
66  GDALRasterBand *poBand;
67  int bTriedToOpen;
68 
69  VRTOverviewInfo() : nBand(0), poBand(nullptr), bTriedToOpen(FALSE) {}
70  ~VRTOverviewInfo() {
71  if( poBand == nullptr )
72  /* do nothing */;
73  else if( poBand->GetDataset()->GetShared() )
74  GDALClose( /* (GDALDatasetH) */ poBand->GetDataset() );
75  else
76  poBand->GetDataset()->Dereference();
77  }
78 };
79 
80 /************************************************************************/
81 /* VRTSource */
82 /************************************************************************/
83 
84 class CPL_DLL VRTSource
85 {
86 public:
87  virtual ~VRTSource();
88 
89  virtual CPLErr RasterIO( GDALDataType eBandDataType,
90  int nXOff, int nYOff, int nXSize, int nYSize,
91  void *pData, int nBufXSize, int nBufYSize,
92  GDALDataType eBufType,
93  GSpacing nPixelSpace, GSpacing nLineSpace,
94  GDALRasterIOExtraArg* psExtraArg ) = 0;
95 
96  virtual double GetMinimum( int nXSize, int nYSize, int *pbSuccess ) = 0;
97  virtual double GetMaximum( int nXSize, int nYSize, int *pbSuccess ) = 0;
98  virtual CPLErr ComputeRasterMinMax( int nXSize, int nYSize, int bApproxOK,
99  double* adfMinMax ) = 0;
100  virtual CPLErr ComputeStatistics( int nXSize, int nYSize,
101  int bApproxOK,
102  double *pdfMin, double *pdfMax,
103  double *pdfMean, double *pdfStdDev,
104  GDALProgressFunc pfnProgress,
105  void *pProgressData ) = 0;
106  virtual CPLErr GetHistogram( int nXSize, int nYSize,
107  double dfMin, double dfMax,
108  int nBuckets, GUIntBig * panHistogram,
109  int bIncludeOutOfRange, int bApproxOK,
110  GDALProgressFunc pfnProgress,
111  void *pProgressData ) = 0;
112 
113  virtual CPLErr XMLInit( CPLXMLNode *psTree, const char *, void* ) = 0;
114  virtual CPLXMLNode *SerializeToXML( const char *pszVRTPath ) = 0;
115 
116  virtual void GetFileList(char*** ppapszFileList, int *pnSize,
117  int *pnMaxSize, CPLHashSet* hSetFiles);
118 
119  virtual int IsSimpleSource() { return FALSE; }
120  virtual CPLErr FlushCache() { return CE_None; }
121 };
122 
123 typedef VRTSource *(*VRTSourceParser)(CPLXMLNode *, const char *, void* pUniqueHandle);
124 
125 VRTSource *VRTParseCoreSources( CPLXMLNode *psTree, const char *, void* pUniqueHandle );
126 VRTSource *VRTParseFilterSources( CPLXMLNode *psTree, const char *, void* pUniqueHandle );
127 
128 /************************************************************************/
129 /* VRTDataset */
130 /************************************************************************/
131 
132 class VRTRasterBand;
133 
134 class CPL_DLL VRTDataset : public GDALDataset
135 {
136  friend class VRTRasterBand;
137 
138  char *m_pszProjection;
139 
140  int m_bGeoTransformSet;
141  double m_adfGeoTransform[6];
142 
143  int m_nGCPCount;
144  GDAL_GCP *m_pasGCPList;
145  char *m_pszGCPProjection;
146 
147  int m_bNeedsFlush;
148  int m_bWritable;
149 
150  char *m_pszVRTPath;
151 
152  VRTRasterBand *m_poMaskBand;
153 
154  int m_bCompatibleForDatasetIO;
155  int CheckCompatibleForDatasetIO();
156  std::vector<GDALDataset*> m_apoOverviews;
157  std::vector<GDALDataset*> m_apoOverviewsBak;
158  char **m_papszXMLVRTMetadata;
159 
160  VRTRasterBand* InitBand(const char* pszSubclass, int nBand,
161  bool bAllowPansharpened);
162 
163  protected:
164  virtual int CloseDependentDatasets() override;
165 
166  public:
167  VRTDataset(int nXSize, int nYSize);
168  virtual ~VRTDataset();
169 
170  void SetNeedsFlush() { m_bNeedsFlush = TRUE; }
171  virtual void FlushCache() override;
172 
173  void SetWritable(int bWritableIn) { m_bWritable = bWritableIn; }
174 
175  virtual CPLErr CreateMaskBand( int nFlags ) override;
176  void SetMaskBand(VRTRasterBand* poMaskBand);
177 
178  virtual const char *GetProjectionRef() override;
179  virtual CPLErr SetProjection( const char * ) override;
180  virtual CPLErr GetGeoTransform( double * ) override;
181  virtual CPLErr SetGeoTransform( double * ) override;
182 
183  virtual CPLErr SetMetadata( char **papszMetadata,
184  const char *pszDomain = "" ) override;
185  virtual CPLErr SetMetadataItem( const char *pszName, const char *pszValue,
186  const char *pszDomain = "" ) override;
187 
188  virtual char** GetMetadata( const char *pszDomain = "" ) override;
189 
190  virtual int GetGCPCount() override;
191  virtual const char *GetGCPProjection() override;
192  virtual const GDAL_GCP *GetGCPs() override;
193  virtual CPLErr SetGCPs( int nGCPCount, const GDAL_GCP *pasGCPList,
194  const char *pszGCPProjection ) override;
195 
196  virtual CPLErr AddBand( GDALDataType eType,
197  char **papszOptions=nullptr ) override;
198 
199  virtual char **GetFileList() override;
200 
201  virtual CPLErr IRasterIO( GDALRWFlag eRWFlag,
202  int nXOff, int nYOff, int nXSize, int nYSize,
203  void * pData, int nBufXSize, int nBufYSize,
204  GDALDataType eBufType,
205  int nBandCount, int *panBandMap,
206  GSpacing nPixelSpace, GSpacing nLineSpace,
207  GSpacing nBandSpace,
208  GDALRasterIOExtraArg* psExtraArg) override;
209 
210  virtual CPLErr AdviseRead( int nXOff, int nYOff, int nXSize, int nYSize,
211  int nBufXSize, int nBufYSize,
212  GDALDataType eDT,
213  int nBandCount, int *panBandList,
214  char **papszOptions ) override;
215 
216  virtual CPLXMLNode *SerializeToXML( const char *pszVRTPath);
217  virtual CPLErr XMLInit( CPLXMLNode *, const char * );
218 
219  virtual CPLErr IBuildOverviews( const char *, int, int *,
220  int, int *, GDALProgressFunc, void * ) override;
221 
222  /* Used by PDF driver for example */
223  GDALDataset* GetSingleSimpleSource();
224  void BuildVirtualOverviews();
225 
226  void UnsetPreservedRelativeFilenames();
227 
228  static int Identify( GDALOpenInfo * );
229  static GDALDataset *Open( GDALOpenInfo * );
230  static GDALDataset *OpenXML( const char *, const char * = nullptr,
231  GDALAccess eAccess = GA_ReadOnly );
232  static GDALDataset *Create( const char * pszName,
233  int nXSize, int nYSize, int nBands,
234  GDALDataType eType, char ** papszOptions );
235  static CPLErr Delete( const char * pszFilename );
236 };
237 
238 /************************************************************************/
239 /* VRTWarpedDataset */
240 /************************************************************************/
241 
242 class GDALWarpOperation;
243 class VRTWarpedRasterBand;
244 
245 class CPL_DLL VRTWarpedDataset : public VRTDataset
246 {
247  int m_nBlockXSize;
248  int m_nBlockYSize;
249  GDALWarpOperation *m_poWarper;
250 
251  int m_nOverviewCount;
252  VRTWarpedDataset **m_papoOverviews;
253  int m_nSrcOvrLevel;
254 
255  void CreateImplicitOverviews();
256 
257  struct VerticalShiftGrid
258  {
259  CPLString osVGrids;
260  int bInverse;
261  double dfToMeterSrc;
262  double dfToMeterDest;
263  CPLStringList aosOptions;
264  };
265  std::vector<VerticalShiftGrid> m_aoVerticalShiftGrids;
266 
267  friend class VRTWarpedRasterBand;
268 
269  protected:
270  virtual int CloseDependentDatasets() override;
271 
272 public:
273  VRTWarpedDataset( int nXSize, int nYSize );
274  virtual ~VRTWarpedDataset();
275 
276  CPLErr Initialize( /* GDALWarpOptions */ void * );
277 
278  virtual CPLErr IBuildOverviews( const char *, int, int *,
279  int, int *, GDALProgressFunc, void * ) override;
280 
281  virtual CPLErr SetMetadataItem( const char *pszName, const char *pszValue,
282  const char *pszDomain = "" ) override;
283 
284  virtual CPLXMLNode *SerializeToXML( const char *pszVRTPath ) override;
285  virtual CPLErr XMLInit( CPLXMLNode *, const char * ) override;
286 
287  virtual CPLErr AddBand( GDALDataType eType,
288  char **papszOptions=nullptr ) override;
289 
290  virtual char **GetFileList() override;
291 
292  CPLErr ProcessBlock( int iBlockX, int iBlockY );
293 
294  void GetBlockSize( int *, int * ) const;
295 
296  void SetApplyVerticalShiftGrid(const char* pszVGrids,
297  int bInverse,
298  double dfToMeterSrc,
299  double dfToMeterDest,
300  char** papszOptions );
301 };
302 
303 /************************************************************************/
304 /* VRTPansharpenedDataset */
305 /************************************************************************/
306 
308 
309 typedef enum
310 {
311  GTAdjust_Union,
312  GTAdjust_Intersection,
313  GTAdjust_None,
314  GTAdjust_NoneWithoutWarning
315 } GTAdjustment;
316 
317 class VRTPansharpenedDataset : public VRTDataset
318 {
319  friend class VRTPansharpenedRasterBand;
320 
321  int m_nBlockXSize;
322  int m_nBlockYSize;
323  GDALPansharpenOperation* m_poPansharpener;
324  VRTPansharpenedDataset* m_poMainDataset;
325  std::vector<VRTPansharpenedDataset*> m_apoOverviewDatasets;
326  // Map from absolute to relative.
327  std::map<CPLString,CPLString> m_oMapToRelativeFilenames;
328 
329  int m_bLoadingOtherBands;
330 
331  GByte *m_pabyLastBufferBandRasterIO;
332  int m_nLastBandRasterIOXOff;
333  int m_nLastBandRasterIOYOff;
334  int m_nLastBandRasterIOXSize;
335  int m_nLastBandRasterIOYSize;
336  GDALDataType m_eLastBandRasterIODataType;
337 
338  GTAdjustment m_eGTAdjustment;
339  int m_bNoDataDisabled;
340 
341  std::vector<GDALDataset*> m_apoDatasetsToClose;
342 
343  protected:
344  virtual int CloseDependentDatasets() override;
345 
346 public:
347  VRTPansharpenedDataset( int nXSize, int nYSize );
348  virtual ~VRTPansharpenedDataset();
349 
350  virtual CPLErr XMLInit( CPLXMLNode *, const char * ) override;
351  virtual CPLXMLNode * SerializeToXML( const char *pszVRTPath ) override;
352 
353  CPLErr XMLInit( CPLXMLNode *psTree, const char *pszVRTPath,
354  GDALRasterBandH hPanchroBandIn,
355  int nInputSpectralBandsIn,
356  GDALRasterBandH* pahInputSpectralBandsIn );
357 
358  virtual CPLErr AddBand( GDALDataType eType,
359  char **papszOptions=nullptr ) override;
360 
361  virtual char **GetFileList() override;
362 
363  virtual CPLErr IRasterIO( GDALRWFlag eRWFlag,
364  int nXOff, int nYOff, int nXSize, int nYSize,
365  void * pData, int nBufXSize, int nBufYSize,
366  GDALDataType eBufType,
367  int nBandCount, int *panBandMap,
368  GSpacing nPixelSpace, GSpacing nLineSpace,
369  GSpacing nBandSpace,
370  GDALRasterIOExtraArg* psExtraArg) override;
371 
372  void GetBlockSize( int *, int * ) const;
373 
374  GDALPansharpenOperation* GetPansharpener() { return m_poPansharpener; }
375 };
376 
377 /************************************************************************/
378 /* VRTRasterBand */
379 /* */
380 /* Provides support for all the various kinds of metadata but */
381 /* no raster access. That is handled by derived classes. */
382 /************************************************************************/
383 
384 class CPL_DLL VRTRasterBand : public GDALRasterBand
385 {
386  protected:
387  int m_bIsMaskBand;
388 
389  int m_bNoDataValueSet;
390  // If set to true, will not report the existence of nodata.
391  int m_bHideNoDataValue;
392  double m_dfNoDataValue;
393 
394  std::unique_ptr<GDALColorTable> m_poColorTable;
395 
396  GDALColorInterp m_eColorInterp;
397 
398  char *m_pszUnitType;
399  char **m_papszCategoryNames;
400 
401  double m_dfOffset;
402  double m_dfScale;
403 
404  CPLXMLNode *m_psSavedHistograms;
405 
406  void Initialize( int nXSize, int nYSize );
407 
408  std::vector<VRTOverviewInfo> m_apoOverviews;
409 
410  VRTRasterBand *m_poMaskBand;
411 
412  std::unique_ptr<GDALRasterAttributeTable> m_poRAT;
413 
414  public:
415 
416  VRTRasterBand();
417  virtual ~VRTRasterBand();
418 
419  virtual CPLErr XMLInit( CPLXMLNode *, const char *, void* );
420  virtual CPLXMLNode * SerializeToXML( const char *pszVRTPath );
421 
422  virtual CPLErr SetNoDataValue( double ) override;
423  virtual double GetNoDataValue( int *pbSuccess = nullptr ) override;
424  virtual CPLErr DeleteNoDataValue() override;
425 
426  virtual CPLErr SetColorTable( GDALColorTable * ) override;
427  virtual GDALColorTable *GetColorTable() override;
428 
429  virtual GDALRasterAttributeTable *GetDefaultRAT() override;
430  virtual CPLErr SetDefaultRAT( const GDALRasterAttributeTable * poRAT ) override;
431 
432  virtual CPLErr SetColorInterpretation( GDALColorInterp ) override;
433  virtual GDALColorInterp GetColorInterpretation() override;
434 
435  virtual const char *GetUnitType() override;
436  CPLErr SetUnitType( const char * ) override;
437 
438  virtual char **GetCategoryNames() override;
439  virtual CPLErr SetCategoryNames( char ** ) override;
440 
441  virtual CPLErr SetMetadata( char **papszMD, const char *pszDomain = "" ) override;
442  virtual CPLErr SetMetadataItem( const char *pszName, const char *pszValue,
443  const char *pszDomain = "" ) override;
444 
445  virtual double GetOffset( int *pbSuccess = nullptr ) override;
446  CPLErr SetOffset( double ) override;
447  virtual double GetScale( int *pbSuccess = nullptr ) override;
448  CPLErr SetScale( double ) override;
449 
450  virtual int GetOverviewCount() override;
451  virtual GDALRasterBand *GetOverview(int) override;
452 
453  virtual CPLErr GetHistogram( double dfMin, double dfMax,
454  int nBuckets, GUIntBig * panHistogram,
455  int bIncludeOutOfRange, int bApproxOK,
456  GDALProgressFunc, void *pProgressData ) override;
457 
458  virtual CPLErr GetDefaultHistogram( double *pdfMin, double *pdfMax,
459  int *pnBuckets, GUIntBig ** ppanHistogram,
460  int bForce,
461  GDALProgressFunc, void *pProgressData) override;
462 
463  virtual CPLErr SetDefaultHistogram( double dfMin, double dfMax,
464  int nBuckets, GUIntBig *panHistogram ) override;
465 
466  CPLErr CopyCommonInfoFrom( GDALRasterBand * );
467 
468  virtual void GetFileList(char*** ppapszFileList, int *pnSize,
469  int *pnMaxSize, CPLHashSet* hSetFiles);
470 
471  virtual void SetDescription( const char * ) override;
472 
473  virtual GDALRasterBand *GetMaskBand() override;
474  virtual int GetMaskFlags() override;
475 
476  virtual CPLErr CreateMaskBand( int nFlagsIn ) override;
477 
478  void SetMaskBand(VRTRasterBand* poMaskBand);
479 
480  void SetIsMaskBand();
481 
482  CPLErr UnsetNoDataValue();
483 
484  virtual int CloseDependentDatasets();
485 
486  virtual int IsSourcedRasterBand() { return FALSE; }
487  virtual int IsPansharpenRasterBand() { return FALSE; }
488 };
489 
490 /************************************************************************/
491 /* VRTSourcedRasterBand */
492 /************************************************************************/
493 
494 class VRTSimpleSource;
495 
496 class CPL_DLL VRTSourcedRasterBand : public VRTRasterBand
497 {
498  private:
499  int m_nRecursionCounter;
500  CPLString m_osLastLocationInfo;
501  char **m_papszSourceList;
502 
503  bool CanUseSourcesMinMaxImplementations();
504  void CheckSource( VRTSimpleSource *poSS );
505 
506  public:
507  int nSources;
508  VRTSource **papoSources;
509  int bSkipBufferInitialization;
510 
511  VRTSourcedRasterBand( GDALDataset *poDS, int nBand );
512  VRTSourcedRasterBand( GDALDataType eType,
513  int nXSize, int nYSize );
514  VRTSourcedRasterBand( GDALDataset *poDS, int nBand,
515  GDALDataType eType,
516  int nXSize, int nYSize );
517  virtual ~VRTSourcedRasterBand();
518 
519  virtual CPLErr IRasterIO( GDALRWFlag, int, int, int, int,
520  void *, int, int, GDALDataType,
521  GSpacing nPixelSpace, GSpacing nLineSpace,
522  GDALRasterIOExtraArg* psExtraArg) override;
523 
524  virtual int IGetDataCoverageStatus( int nXOff, int nYOff,
525  int nXSize, int nYSize,
526  int nMaskFlagStop,
527  double* pdfDataPct) override;
528 
529  virtual char **GetMetadataDomainList() override;
530  virtual const char *GetMetadataItem( const char * pszName,
531  const char * pszDomain = "" ) override;
532  virtual char **GetMetadata( const char * pszDomain = "" ) override;
533  virtual CPLErr SetMetadata( char ** papszMetadata,
534  const char * pszDomain = "" ) override;
535  virtual CPLErr SetMetadataItem( const char * pszName,
536  const char * pszValue,
537  const char * pszDomain = "" ) override;
538 
539  virtual CPLErr XMLInit( CPLXMLNode *, const char *, void* ) override;
540  virtual CPLXMLNode * SerializeToXML( const char *pszVRTPath ) override;
541 
542  virtual double GetMinimum( int *pbSuccess = nullptr ) override;
543  virtual double GetMaximum(int *pbSuccess = nullptr ) override;
544  virtual CPLErr ComputeRasterMinMax( int bApproxOK, double* adfMinMax ) override;
545  virtual CPLErr ComputeStatistics( int bApproxOK,
546  double *pdfMin, double *pdfMax,
547  double *pdfMean, double *pdfStdDev,
548  GDALProgressFunc pfnProgress,
549  void *pProgressData ) override;
550  virtual CPLErr GetHistogram( double dfMin, double dfMax,
551  int nBuckets, GUIntBig * panHistogram,
552  int bIncludeOutOfRange, int bApproxOK,
553  GDALProgressFunc pfnProgress,
554  void *pProgressData ) override;
555 
556  CPLErr AddSource( VRTSource * );
557  CPLErr AddSimpleSource( GDALRasterBand *poSrcBand,
558  double dfSrcXOff=-1, double dfSrcYOff=-1,
559  double dfSrcXSize=-1, double dfSrcYSize=-1,
560  double dfDstXOff=-1, double dfDstYOff=-1,
561  double dfDstXSize=-1, double dfDstYSize=-1,
562  const char *pszResampling = "near",
563  double dfNoDataValue = VRT_NODATA_UNSET);
564  CPLErr AddComplexSource( GDALRasterBand *poSrcBand,
565  double dfSrcXOff=-1, double dfSrcYOff=-1,
566  double dfSrcXSize=-1, double dfSrcYSize=-1,
567  double dfDstXOff=-1, double dfDstYOff=-1,
568  double dfDstXSize=-1, double dfDstYSize=-1,
569  double dfScaleOff=0.0,
570  double dfScaleRatio=1.0,
571  double dfNoDataValue = VRT_NODATA_UNSET,
572  int nColorTableComponent = 0);
573 
574  CPLErr AddMaskBandSource( GDALRasterBand *poSrcBand,
575  double dfSrcXOff=-1, double dfSrcYOff=-1,
576  double dfSrcXSize=-1,
577  double dfSrcYSize=-1,
578  double dfDstXOff=-1, double dfDstYOff=-1,
579  double dfDstXSize=-1,
580  double dfDstYSize=-1 );
581 
582  CPLErr AddFuncSource( VRTImageReadFunc pfnReadFunc, void *hCBData,
583  double dfNoDataValue = VRT_NODATA_UNSET );
584 
585  void ConfigureSource(VRTSimpleSource *poSimpleSource,
586  GDALRasterBand *poSrcBand,
587  int bAddAsMaskBand,
588  double dfSrcXOff, double dfSrcYOff,
589  double dfSrcXSize, double dfSrcYSize,
590  double dfDstXOff, double dfDstYOff,
591  double dfDstXSize, double dfDstYSize );
592 
593  virtual CPLErr IReadBlock( int, int, void * ) override;
594 
595  virtual void GetFileList(char*** ppapszFileList, int *pnSize,
596  int *pnMaxSize, CPLHashSet* hSetFiles) override;
597 
598  virtual int CloseDependentDatasets() override;
599 
600  virtual int IsSourcedRasterBand() override { return TRUE; }
601 
602  virtual CPLErr FlushCache() override;
603 };
604 
605 /************************************************************************/
606 /* VRTWarpedRasterBand */
607 /************************************************************************/
608 
609 class CPL_DLL VRTWarpedRasterBand : public VRTRasterBand
610 {
611  public:
612  VRTWarpedRasterBand( GDALDataset *poDS, int nBand,
613  GDALDataType eType = GDT_Unknown );
614  virtual ~VRTWarpedRasterBand();
615 
616  virtual CPLXMLNode * SerializeToXML( const char *pszVRTPath ) override;
617 
618  virtual CPLErr IReadBlock( int, int, void * ) override;
619  virtual CPLErr IWriteBlock( int, int, void * ) override;
620 
621  virtual int GetOverviewCount() override;
622  virtual GDALRasterBand *GetOverview(int) override;
623 };
624 /************************************************************************/
625 /* VRTPansharpenedRasterBand */
626 /************************************************************************/
627 
628 class VRTPansharpenedRasterBand : public VRTRasterBand
629 {
630  int m_nIndexAsPansharpenedBand;
631 
632  public:
633  VRTPansharpenedRasterBand(
634  GDALDataset *poDS, int nBand,
635  GDALDataType eDataType = GDT_Unknown );
636  virtual ~VRTPansharpenedRasterBand();
637 
638  virtual CPLXMLNode * SerializeToXML( const char *pszVRTPath ) override;
639 
640  virtual CPLErr IReadBlock( int, int, void * ) override;
641 
642  virtual CPLErr IRasterIO( GDALRWFlag eRWFlag,
643  int nXOff, int nYOff, int nXSize, int nYSize,
644  void * pData, int nBufXSize, int nBufYSize,
645  GDALDataType eBufType,
646  GSpacing nPixelSpace, GSpacing nLineSpace,
647  GDALRasterIOExtraArg* psExtraArg) override;
648 
649  virtual int GetOverviewCount() override;
650  virtual GDALRasterBand *GetOverview(int) override;
651 
652  virtual int IsPansharpenRasterBand() override { return TRUE; }
653 
654  void SetIndexAsPansharpenedBand( int nIdx )
655  { m_nIndexAsPansharpenedBand = nIdx; }
656  int GetIndexAsPansharpenedBand() const
657  { return m_nIndexAsPansharpenedBand; }
658 };
659 
660 /************************************************************************/
661 /* VRTDerivedRasterBand */
662 /************************************************************************/
663 
664 class VRTDerivedRasterBandPrivateData;
665 
666 class CPL_DLL VRTDerivedRasterBand : public VRTSourcedRasterBand
667 {
668  VRTDerivedRasterBandPrivateData* m_poPrivate;
669  bool InitializePython();
670 
671  public:
672  char *pszFuncName;
673  GDALDataType eSourceTransferType;
674 
675  VRTDerivedRasterBand( GDALDataset *poDS, int nBand );
676  VRTDerivedRasterBand( GDALDataset *poDS, int nBand,
677  GDALDataType eType, int nXSize, int nYSize );
678  virtual ~VRTDerivedRasterBand();
679 
680  virtual CPLErr IRasterIO( GDALRWFlag, int, int, int, int,
681  void *, int, int, GDALDataType,
682  GSpacing nPixelSpace, GSpacing nLineSpace,
683  GDALRasterIOExtraArg* psExtraArg ) override;
684 
685  virtual int IGetDataCoverageStatus( int nXOff, int nYOff,
686  int nXSize, int nYSize,
687  int nMaskFlagStop,
688  double* pdfDataPct) override;
689 
690  static CPLErr AddPixelFunction( const char *pszFuncName,
691  GDALDerivedPixelFunc pfnPixelFunc );
692  static GDALDerivedPixelFunc GetPixelFunction( const char *pszFuncName );
693 
694  void SetPixelFunctionName( const char *pszFuncName );
695  void SetSourceTransferType( GDALDataType eDataType );
696  void SetPixelFunctionLanguage( const char* pszLanguage );
697 
698  virtual CPLErr XMLInit( CPLXMLNode *, const char *, void* ) override;
699  virtual CPLXMLNode * SerializeToXML( const char *pszVRTPath ) override;
700 
701  virtual double GetMinimum( int *pbSuccess = nullptr ) override;
702  virtual double GetMaximum(int *pbSuccess = nullptr ) override;
703  virtual CPLErr ComputeRasterMinMax( int bApproxOK, double* adfMinMax ) override;
704  virtual CPLErr ComputeStatistics( int bApproxOK,
705  double *pdfMin, double *pdfMax,
706  double *pdfMean, double *pdfStdDev,
707  GDALProgressFunc pfnProgress,
708  void *pProgressData ) override;
709  virtual CPLErr GetHistogram( double dfMin, double dfMax,
710  int nBuckets, GUIntBig * panHistogram,
711  int bIncludeOutOfRange, int bApproxOK,
712  GDALProgressFunc pfnProgress,
713  void *pProgressData ) override;
714 
715  static void Cleanup();
716 };
717 
718 /************************************************************************/
719 /* VRTRawRasterBand */
720 /************************************************************************/
721 
722 class RawRasterBand;
723 
724 class CPL_DLL VRTRawRasterBand : public VRTRasterBand
725 {
726  RawRasterBand *m_poRawRaster;
727 
728  char *m_pszSourceFilename;
729  int m_bRelativeToVRT;
730 
731  public:
732  VRTRawRasterBand( GDALDataset *poDS, int nBand,
733  GDALDataType eType = GDT_Unknown );
734  virtual ~VRTRawRasterBand();
735 
736  virtual CPLErr XMLInit( CPLXMLNode *, const char *, void* ) override;
737  virtual CPLXMLNode * SerializeToXML( const char *pszVRTPath ) override;
738 
739  virtual CPLErr IRasterIO( GDALRWFlag, int, int, int, int,
740  void *, int, int, GDALDataType,
741  GSpacing nPixelSpace, GSpacing nLineSpace,
742  GDALRasterIOExtraArg* psExtraArg ) override;
743 
744  virtual CPLErr IReadBlock( int, int, void * ) override;
745  virtual CPLErr IWriteBlock( int, int, void * ) override;
746 
747  CPLErr SetRawLink( const char *pszFilename,
748  const char *pszVRTPath,
749  int bRelativeToVRT,
750  vsi_l_offset nImageOffset,
751  int nPixelOffset, int nLineOffset,
752  const char *pszByteOrder );
753 
754  void ClearRawLink();
755 
756  virtual void GetFileList( char*** ppapszFileList, int *pnSize,
757  int *pnMaxSize, CPLHashSet* hSetFiles ) override;
758 };
759 
760 /************************************************************************/
761 /* VRTDriver */
762 /************************************************************************/
763 
764 class VRTDriver : public GDALDriver
765 {
766  public:
767  VRTDriver();
768  virtual ~VRTDriver();
769 
770  char **papszSourceParsers;
771 
772  virtual char **GetMetadataDomainList() override;
773  virtual char **GetMetadata( const char * pszDomain = "" ) override;
774  virtual CPLErr SetMetadata( char ** papszMetadata,
775  const char * pszDomain = "" ) override;
776 
777  VRTSource *ParseSource( CPLXMLNode *psSrc, const char *pszVRTPath,
778  void* pUniqueHandle );
779  void AddSourceParser( const char *pszElementName,
780  VRTSourceParser pfnParser );
781 };
782 
783 /************************************************************************/
784 /* VRTSimpleSource */
785 /************************************************************************/
786 
787 class CPL_DLL VRTSimpleSource : public VRTSource
788 {
789 protected:
790  friend class VRTSourcedRasterBand;
791 
792  GDALRasterBand *m_poRasterBand;
793 
794  // When poRasterBand is a mask band, poMaskBandMainBand is the band
795  // from which the mask band is taken.
796  GDALRasterBand *m_poMaskBandMainBand;
797 
798  double m_dfSrcXOff;
799  double m_dfSrcYOff;
800  double m_dfSrcXSize;
801  double m_dfSrcYSize;
802 
803  double m_dfDstXOff;
804  double m_dfDstYOff;
805  double m_dfDstXSize;
806  double m_dfDstYSize;
807 
808  int m_bNoDataSet;
809  double m_dfNoDataValue;
810  CPLString m_osResampling;
811 
812  int m_nMaxValue;
813 
814  int m_bRelativeToVRTOri;
815  CPLString m_osSourceFileNameOri;
816  int m_nExplicitSharedStatus; // -1 unknown, 0 = unshared, 1 = shared
817 
818  int NeedMaxValAdjustment() const;
819 
820 public:
821  VRTSimpleSource();
822  VRTSimpleSource( const VRTSimpleSource* poSrcSource,
823  double dfXDstRatio, double dfYDstRatio );
824  virtual ~VRTSimpleSource();
825 
826  virtual CPLErr XMLInit( CPLXMLNode *psTree, const char *, void* ) override;
827  virtual CPLXMLNode *SerializeToXML( const char *pszVRTPath ) override;
828 
829  void SetSrcBand( GDALRasterBand * );
830  void SetSrcMaskBand( GDALRasterBand * );
831  void SetSrcWindow( double, double, double, double );
832  void SetDstWindow( double, double, double, double );
833  void SetNoDataValue( double dfNoDataValue );
834  const CPLString& GetResampling() const { return m_osResampling; }
835  void SetResampling( const char* pszResampling );
836 
837  int GetSrcDstWindow( int, int, int, int, int, int,
838  double *pdfReqXOff, double *pdfReqYOff,
839  double *pdfReqXSize, double *pdfReqYSize,
840  int *, int *, int *, int *,
841  int *, int *, int *, int * );
842 
843  virtual CPLErr RasterIO( GDALDataType eBandDataType,
844  int nXOff, int nYOff, int nXSize, int nYSize,
845  void *pData, int nBufXSize, int nBufYSize,
846  GDALDataType eBufType,
847  GSpacing nPixelSpace, GSpacing nLineSpace,
848  GDALRasterIOExtraArg* psExtraArgIn ) override;
849 
850  virtual double GetMinimum( int nXSize, int nYSize, int *pbSuccess ) override;
851  virtual double GetMaximum( int nXSize, int nYSize, int *pbSuccess ) override;
852  virtual CPLErr ComputeRasterMinMax( int nXSize, int nYSize, int bApproxOK,
853  double* adfMinMax ) override;
854  virtual CPLErr ComputeStatistics( int nXSize, int nYSize,
855  int bApproxOK,
856  double *pdfMin, double *pdfMax,
857  double *pdfMean, double *pdfStdDev,
858  GDALProgressFunc pfnProgress,
859  void *pProgressData ) override;
860  virtual CPLErr GetHistogram( int nXSize, int nYSize,
861  double dfMin, double dfMax,
862  int nBuckets, GUIntBig * panHistogram,
863  int bIncludeOutOfRange, int bApproxOK,
864  GDALProgressFunc pfnProgress,
865  void *pProgressData ) override;
866 
867  void DstToSrc( double dfX, double dfY,
868  double &dfXOut, double &dfYOut ) const;
869  void SrcToDst( double dfX, double dfY,
870  double &dfXOut, double &dfYOut ) const;
871 
872  virtual void GetFileList( char*** ppapszFileList, int *pnSize,
873  int *pnMaxSize, CPLHashSet* hSetFiles ) override;
874 
875  virtual int IsSimpleSource() override { return TRUE; }
876  virtual const char* GetType() { return "SimpleSource"; }
877  virtual CPLErr FlushCache() override;
878 
879  GDALRasterBand* GetBand();
880  int IsSameExceptBandNumber( VRTSimpleSource* poOtherSource );
881  CPLErr DatasetRasterIO(
882  GDALDataType eBandDataType,
883  int nXOff, int nYOff, int nXSize, int nYSize,
884  void * pData, int nBufXSize, int nBufYSize,
885  GDALDataType eBufType,
886  int nBandCount, int *panBandMap,
887  GSpacing nPixelSpace, GSpacing nLineSpace,
888  GSpacing nBandSpace,
889  GDALRasterIOExtraArg* psExtraArg );
890 
891  void UnsetPreservedRelativeFilenames();
892 
893  void SetMaxValue( int nVal ) { m_nMaxValue = nVal; }
894 };
895 
896 /************************************************************************/
897 /* VRTAveragedSource */
898 /************************************************************************/
899 
900 class VRTAveragedSource : public VRTSimpleSource
901 {
902 public:
903  VRTAveragedSource();
904  virtual CPLErr RasterIO( GDALDataType eBandDataType,
905  int nXOff, int nYOff, int nXSize, int nYSize,
906  void *pData, int nBufXSize, int nBufYSize,
907  GDALDataType eBufType,
908  GSpacing nPixelSpace, GSpacing nLineSpace,
909  GDALRasterIOExtraArg* psExtraArgIn ) override;
910 
911  virtual double GetMinimum( int nXSize, int nYSize, int *pbSuccess ) override;
912  virtual double GetMaximum( int nXSize, int nYSize, int *pbSuccess ) override;
913  virtual CPLErr ComputeRasterMinMax( int nXSize, int nYSize, int bApproxOK,
914  double* adfMinMax ) override;
915  virtual CPLErr ComputeStatistics( int nXSize, int nYSize,
916  int bApproxOK,
917  double *pdfMin, double *pdfMax,
918  double *pdfMean, double *pdfStdDev,
919  GDALProgressFunc pfnProgress,
920  void *pProgressData ) override;
921  virtual CPLErr GetHistogram( int nXSize, int nYSize,
922  double dfMin, double dfMax,
923  int nBuckets, GUIntBig * panHistogram,
924  int bIncludeOutOfRange, int bApproxOK,
925  GDALProgressFunc pfnProgress,
926  void *pProgressData ) override;
927 
928  virtual CPLXMLNode *SerializeToXML( const char *pszVRTPath ) override;
929  virtual const char* GetType() override { return "AveragedSource"; }
930 };
931 
932 /************************************************************************/
933 /* VRTComplexSource */
934 /************************************************************************/
935 
936 typedef enum
937 {
938  VRT_SCALING_NONE,
939  VRT_SCALING_LINEAR,
940  VRT_SCALING_EXPONENTIAL,
941 } VRTComplexSourceScaling;
942 
943 class CPL_DLL VRTComplexSource : public VRTSimpleSource
944 {
945 protected:
946  VRTComplexSourceScaling m_eScalingType;
947  double m_dfScaleOff; // For linear scaling.
948  double m_dfScaleRatio; // For linear scaling.
949 
950  // For non-linear scaling with a power function.
951  int m_bSrcMinMaxDefined;
952  double m_dfSrcMin;
953  double m_dfSrcMax;
954  double m_dfDstMin;
955  double m_dfDstMax;
956  double m_dfExponent;
957 
958  int m_nColorTableComponent;
959 
960  template <class WorkingDT>
961  CPLErr RasterIOInternal( int nReqXOff, int nReqYOff,
962  int nReqXSize, int nReqYSize,
963  void *pData, int nOutXSize, int nOutYSize,
964  GDALDataType eBufType,
965  GSpacing nPixelSpace, GSpacing nLineSpace,
966  GDALRasterIOExtraArg* psExtraArg,
967  GDALDataType eWrkDataType );
968 
969 public:
970  VRTComplexSource();
971  VRTComplexSource(const VRTComplexSource* poSrcSource,
972  double dfXDstRatio, double dfYDstRatio);
973  virtual ~VRTComplexSource();
974 
975  virtual CPLErr RasterIO( GDALDataType eBandDataType,
976  int nXOff, int nYOff, int nXSize, int nYSize,
977  void *pData, int nBufXSize, int nBufYSize,
978  GDALDataType eBufType,
979  GSpacing nPixelSpace, GSpacing nLineSpace,
980  GDALRasterIOExtraArg* psExtraArgIn ) override;
981 
982  virtual double GetMinimum( int nXSize, int nYSize, int *pbSuccess ) override;
983  virtual double GetMaximum( int nXSize, int nYSize, int *pbSuccess ) override;
984  virtual CPLErr ComputeRasterMinMax( int nXSize, int nYSize, int bApproxOK,
985  double* adfMinMax ) override;
986  virtual CPLErr ComputeStatistics( int nXSize, int nYSize,
987  int bApproxOK,
988  double *pdfMin, double *pdfMax,
989  double *pdfMean, double *pdfStdDev,
990  GDALProgressFunc pfnProgress,
991  void *pProgressData ) override;
992  virtual CPLErr GetHistogram( int nXSize, int nYSize,
993  double dfMin, double dfMax,
994  int nBuckets, GUIntBig * panHistogram,
995  int bIncludeOutOfRange, int bApproxOK,
996  GDALProgressFunc pfnProgress,
997  void *pProgressData ) override;
998 
999  virtual CPLXMLNode *SerializeToXML( const char *pszVRTPath ) override;
1000  virtual CPLErr XMLInit( CPLXMLNode *, const char *, void* ) override;
1001  virtual const char* GetType() override { return "ComplexSource"; }
1002 
1003  double LookupValue( double dfInput );
1004 
1005  void SetLinearScaling( double dfOffset, double dfScale );
1006  void SetPowerScaling( double dfExponent,
1007  double dfSrcMin,
1008  double dfSrcMax,
1009  double dfDstMin,
1010  double dfDstMax );
1011  void SetColorTableComponent( int nComponent );
1012 
1013  double *m_padfLUTInputs;
1014  double *m_padfLUTOutputs;
1015  int m_nLUTItemCount;
1016 };
1017 
1018 /************************************************************************/
1019 /* VRTFilteredSource */
1020 /************************************************************************/
1021 
1022 class VRTFilteredSource : public VRTComplexSource
1023 {
1024 private:
1025  int IsTypeSupported( GDALDataType eTestType ) const;
1026 
1027 protected:
1028  int m_nSupportedTypesCount;
1029  GDALDataType m_aeSupportedTypes[20];
1030 
1031  int m_nExtraEdgePixels;
1032 
1033 public:
1034  VRTFilteredSource();
1035  virtual ~VRTFilteredSource();
1036 
1037  void SetExtraEdgePixels( int );
1038  void SetFilteringDataTypesSupported( int, GDALDataType * );
1039 
1040  virtual CPLErr FilterData( int nXSize, int nYSize, GDALDataType eType,
1041  GByte *pabySrcData, GByte *pabyDstData ) = 0;
1042 
1043  virtual CPLErr RasterIO( GDALDataType eBandDataType,
1044  int nXOff, int nYOff, int nXSize, int nYSize,
1045  void *pData, int nBufXSize, int nBufYSize,
1046  GDALDataType eBufType,
1047  GSpacing nPixelSpace, GSpacing nLineSpace,
1048  GDALRasterIOExtraArg* psExtraArg ) override;
1049 };
1050 
1051 /************************************************************************/
1052 /* VRTKernelFilteredSource */
1053 /************************************************************************/
1054 
1055 class VRTKernelFilteredSource : public VRTFilteredSource
1056 {
1057 protected:
1058  int m_nKernelSize;
1059 
1060  bool m_bSeparable;
1061 
1062  double *m_padfKernelCoefs;
1063 
1064  int m_bNormalized;
1065 
1066 public:
1067  VRTKernelFilteredSource();
1068  virtual ~VRTKernelFilteredSource();
1069 
1070  virtual CPLErr XMLInit( CPLXMLNode *psTree, const char *, void* ) override;
1071  virtual CPLXMLNode *SerializeToXML( const char *pszVRTPath ) override;
1072 
1073  virtual CPLErr FilterData( int nXSize, int nYSize, GDALDataType eType,
1074  GByte *pabySrcData, GByte *pabyDstData ) override;
1075 
1076  CPLErr SetKernel( int nKernelSize, bool bSeparable, double *padfCoefs );
1077  void SetNormalized( int );
1078 };
1079 
1080 /************************************************************************/
1081 /* VRTAverageFilteredSource */
1082 /************************************************************************/
1083 
1084 class VRTAverageFilteredSource : public VRTKernelFilteredSource
1085 {
1086 public:
1087  explicit VRTAverageFilteredSource( int nKernelSize );
1088  virtual ~VRTAverageFilteredSource();
1089 
1090  virtual CPLErr XMLInit( CPLXMLNode *psTree, const char *, void* ) override;
1091  virtual CPLXMLNode *SerializeToXML( const char *pszVRTPath ) override;
1092 };
1093 
1094 /************************************************************************/
1095 /* VRTFuncSource */
1096 /************************************************************************/
1097 class VRTFuncSource : public VRTSource
1098 {
1099 public:
1100  VRTFuncSource();
1101  virtual ~VRTFuncSource();
1102 
1103  virtual CPLErr XMLInit( CPLXMLNode *, const char *, void* ) override { return CE_Failure; }
1104  virtual CPLXMLNode *SerializeToXML( const char *pszVRTPath ) override;
1105 
1106  virtual CPLErr RasterIO( GDALDataType eBandDataType,
1107  int nXOff, int nYOff, int nXSize, int nYSize,
1108  void *pData, int nBufXSize, int nBufYSize,
1109  GDALDataType eBufType,
1110  GSpacing nPixelSpace, GSpacing nLineSpace,
1111  GDALRasterIOExtraArg* psExtraArg ) override;
1112 
1113  virtual double GetMinimum( int nXSize, int nYSize, int *pbSuccess ) override;
1114  virtual double GetMaximum( int nXSize, int nYSize, int *pbSuccess ) override;
1115  virtual CPLErr ComputeRasterMinMax( int nXSize, int nYSize, int bApproxOK,
1116  double* adfMinMax ) override;
1117  virtual CPLErr ComputeStatistics( int nXSize, int nYSize,
1118  int bApproxOK,
1119  double *pdfMin, double *pdfMax,
1120  double *pdfMean, double *pdfStdDev,
1121  GDALProgressFunc pfnProgress,
1122  void *pProgressData ) override;
1123  virtual CPLErr GetHistogram( int nXSize, int nYSize,
1124  double dfMin, double dfMax,
1125  int nBuckets, GUIntBig * panHistogram,
1126  int bIncludeOutOfRange, int bApproxOK,
1127  GDALProgressFunc pfnProgress,
1128  void *pProgressData ) override;
1129 
1130  VRTImageReadFunc pfnReadFunc;
1131  void *pCBData;
1132  GDALDataType eType;
1133 
1134  float fNoDataValue;
1135 };
1136 
1137 #endif /* #ifndef DOXYGEN_SKIP */
1138 
1139 #endif /* ndef VIRTUALDATASET_H_INCLUDED */
The GDALRasterAttributeTable (or RAT) class is used to encapsulate a table used to provide attribute ...
Definition: gdal_rat.h:47
GDALDataType
Definition: gdal.h:60
Document node structure.
Definition: cpl_minixml.h:66
CPLErr(* VRTImageReadFunc)(void *hCBData, int nXOff, int nYOff, int nXSize, int nYSize, void *pData)
Type for a function that returns the pixel data in a provided window.
Definition: gdal_vrt.h:51
C++ GDAL entry points.
GDALRWFlag
Definition: gdal.h:119
unsigned char GByte
Unsigned byte type.
Definition: cpl_port.h:213
void * GDALRasterBandH
Opaque type used for the C bindings of the C++ GDALRasterBand class.
Definition: gdal.h:258
Pansharpening operation class.
Definition: gdalpansharpen.h:188
Convenient string class based on std::string.
Definition: cpl_string.h:336
Hash set implementation.
Definition: gdal.h:61
CPLErr(* GDALDerivedPixelFunc)(void **papoSources, int nSources, void *pData, int nBufXSize, int nBufYSize, GDALDataType eSrcType, GDALDataType eBufType, int nPixelSpace, int nLineSpace)
Type of functions to pass to GDALAddDerivedBandPixelFunc.
Definition: gdal.h:766
#define VRT_NODATA_UNSET
Special value to indicate that nodata is not set.
Definition: gdal_vrt.h:45
GIntBig GSpacing
Type to express pixel, line or band spacing.
Definition: gdal.h:273
int Dereference()
Subtract one from dataset reference count.
Definition: gdaldataset.cpp:1162
Class for dataset open functions.
Definition: gdal_priv.h:265
String list class designed around our use of C "char**" string lists.
Definition: cpl_string.h:447
Structure to pass extra arguments to RasterIO() method.
Definition: gdal.h:147
High level image warping class.
Definition: gdalwarper.h:438
unsigned long long GUIntBig
Large unsigned integer type (generally 64-bit unsigned integer type).
Definition: cpl_port.h:249
void GDALClose(GDALDatasetH)
Close GDAL dataset.
Definition: gdaldataset.cpp:3059
Object with metadata.
Definition: gdal_priv.h:132
GDALDataset * GetDataset()
Fetch the owning dataset handle.
Definition: gdalrasterband.cpp:2853
GUIntBig vsi_l_offset
Type for a file offset.
Definition: cpl_vsi.h:139
A single raster band (or channel).
Definition: gdal_priv.h:1042
GDALAccess
Definition: gdal.h:113
A set of associated raster bands, usually from one file.
Definition: gdal_priv.h:339
GDALColorInterp
Definition: gdal.h:190
Public (C callable) entry points for virtual GDAL dataset objects.
struct _CPLHashSet CPLHashSet
Opaque type for a hash set.
Definition: cpl_hash_set.h:52
Definition: gdal.h:114
Format specific driver.
Definition: gdal_priv.h:1386
A color table / palette.
Definition: gdal_priv.h:949
int GetShared() const
Returns shared flag.
Definition: gdaldataset.cpp:1234
Ground Control Point.
Definition: gdal.h:560
CPLErr
Error category.
Definition: cpl_error.h:52

Generated for GDAL by doxygen 1.8.13.