GDAL
vrtdataset.h
1 /******************************************************************************
2  * $Id$
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  CPL_DISALLOW_COPY_ASSIGN(VRTDerivedRasterBand)
672 
673  public:
674  char *pszFuncName;
675  GDALDataType eSourceTransferType;
676 
677  VRTDerivedRasterBand( GDALDataset *poDS, int nBand );
678  VRTDerivedRasterBand( GDALDataset *poDS, int nBand,
679  GDALDataType eType, int nXSize, int nYSize );
680  virtual ~VRTDerivedRasterBand();
681 
682  virtual CPLErr IRasterIO( GDALRWFlag, int, int, int, int,
683  void *, int, int, GDALDataType,
684  GSpacing nPixelSpace, GSpacing nLineSpace,
685  GDALRasterIOExtraArg* psExtraArg ) override;
686 
687  virtual int IGetDataCoverageStatus( int nXOff, int nYOff,
688  int nXSize, int nYSize,
689  int nMaskFlagStop,
690  double* pdfDataPct) override;
691 
692  static CPLErr AddPixelFunction( const char *pszFuncName,
693  GDALDerivedPixelFunc pfnPixelFunc );
694  static GDALDerivedPixelFunc GetPixelFunction( const char *pszFuncName );
695 
696  void SetPixelFunctionName( const char *pszFuncName );
697  void SetSourceTransferType( GDALDataType eDataType );
698  void SetPixelFunctionLanguage( const char* pszLanguage );
699 
700  virtual CPLErr XMLInit( CPLXMLNode *, const char *, void* ) override;
701  virtual CPLXMLNode * SerializeToXML( const char *pszVRTPath ) override;
702 
703  virtual double GetMinimum( int *pbSuccess = nullptr ) override;
704  virtual double GetMaximum(int *pbSuccess = nullptr ) override;
705  virtual CPLErr ComputeRasterMinMax( int bApproxOK, double* adfMinMax ) override;
706  virtual CPLErr ComputeStatistics( int bApproxOK,
707  double *pdfMin, double *pdfMax,
708  double *pdfMean, double *pdfStdDev,
709  GDALProgressFunc pfnProgress,
710  void *pProgressData ) override;
711  virtual CPLErr GetHistogram( double dfMin, double dfMax,
712  int nBuckets, GUIntBig * panHistogram,
713  int bIncludeOutOfRange, int bApproxOK,
714  GDALProgressFunc pfnProgress,
715  void *pProgressData ) override;
716 
717  static void Cleanup();
718 };
719 
720 /************************************************************************/
721 /* VRTRawRasterBand */
722 /************************************************************************/
723 
724 class RawRasterBand;
725 
726 class CPL_DLL VRTRawRasterBand : public VRTRasterBand
727 {
728  RawRasterBand *m_poRawRaster;
729 
730  char *m_pszSourceFilename;
731  int m_bRelativeToVRT;
732 
733  public:
734  VRTRawRasterBand( GDALDataset *poDS, int nBand,
735  GDALDataType eType = GDT_Unknown );
736  virtual ~VRTRawRasterBand();
737 
738  virtual CPLErr XMLInit( CPLXMLNode *, const char *, void* ) override;
739  virtual CPLXMLNode * SerializeToXML( const char *pszVRTPath ) override;
740 
741  virtual CPLErr IRasterIO( GDALRWFlag, int, int, int, int,
742  void *, int, int, GDALDataType,
743  GSpacing nPixelSpace, GSpacing nLineSpace,
744  GDALRasterIOExtraArg* psExtraArg ) override;
745 
746  virtual CPLErr IReadBlock( int, int, void * ) override;
747  virtual CPLErr IWriteBlock( int, int, void * ) override;
748 
749  CPLErr SetRawLink( const char *pszFilename,
750  const char *pszVRTPath,
751  int bRelativeToVRT,
752  vsi_l_offset nImageOffset,
753  int nPixelOffset, int nLineOffset,
754  const char *pszByteOrder );
755 
756  void ClearRawLink();
757 
758  virtual void GetFileList( char*** ppapszFileList, int *pnSize,
759  int *pnMaxSize, CPLHashSet* hSetFiles ) override;
760 };
761 
762 /************************************************************************/
763 /* VRTDriver */
764 /************************************************************************/
765 
766 class VRTDriver : public GDALDriver
767 {
768  public:
769  VRTDriver();
770  virtual ~VRTDriver();
771 
772  char **papszSourceParsers;
773 
774  virtual char **GetMetadataDomainList() override;
775  virtual char **GetMetadata( const char * pszDomain = "" ) override;
776  virtual CPLErr SetMetadata( char ** papszMetadata,
777  const char * pszDomain = "" ) override;
778 
779  VRTSource *ParseSource( CPLXMLNode *psSrc, const char *pszVRTPath,
780  void* pUniqueHandle );
781  void AddSourceParser( const char *pszElementName,
782  VRTSourceParser pfnParser );
783 };
784 
785 /************************************************************************/
786 /* VRTSimpleSource */
787 /************************************************************************/
788 
789 class CPL_DLL VRTSimpleSource : public VRTSource
790 {
791 protected:
792  friend class VRTSourcedRasterBand;
793 
794  GDALRasterBand *m_poRasterBand;
795 
796  // When poRasterBand is a mask band, poMaskBandMainBand is the band
797  // from which the mask band is taken.
798  GDALRasterBand *m_poMaskBandMainBand;
799 
800  double m_dfSrcXOff;
801  double m_dfSrcYOff;
802  double m_dfSrcXSize;
803  double m_dfSrcYSize;
804 
805  double m_dfDstXOff;
806  double m_dfDstYOff;
807  double m_dfDstXSize;
808  double m_dfDstYSize;
809 
810  int m_bNoDataSet;
811  double m_dfNoDataValue;
812  CPLString m_osResampling;
813 
814  int m_nMaxValue;
815 
816  int m_bRelativeToVRTOri;
817  CPLString m_osSourceFileNameOri;
818  int m_nExplicitSharedStatus; // -1 unknown, 0 = unshared, 1 = shared
819 
820  int NeedMaxValAdjustment() const;
821 
822 public:
823  VRTSimpleSource();
824  VRTSimpleSource( const VRTSimpleSource* poSrcSource,
825  double dfXDstRatio, double dfYDstRatio );
826  virtual ~VRTSimpleSource();
827 
828  virtual CPLErr XMLInit( CPLXMLNode *psTree, const char *, void* ) override;
829  virtual CPLXMLNode *SerializeToXML( const char *pszVRTPath ) override;
830 
831  void SetSrcBand( GDALRasterBand * );
832  void SetSrcMaskBand( GDALRasterBand * );
833  void SetSrcWindow( double, double, double, double );
834  void SetDstWindow( double, double, double, double );
835  void SetNoDataValue( double dfNoDataValue );
836  const CPLString& GetResampling() const { return m_osResampling; }
837  void SetResampling( const char* pszResampling );
838 
839  int GetSrcDstWindow( int, int, int, int, int, int,
840  double *pdfReqXOff, double *pdfReqYOff,
841  double *pdfReqXSize, double *pdfReqYSize,
842  int *, int *, int *, int *,
843  int *, int *, int *, int * );
844 
845  virtual CPLErr RasterIO( GDALDataType eBandDataType,
846  int nXOff, int nYOff, int nXSize, int nYSize,
847  void *pData, int nBufXSize, int nBufYSize,
848  GDALDataType eBufType,
849  GSpacing nPixelSpace, GSpacing nLineSpace,
850  GDALRasterIOExtraArg* psExtraArgIn ) override;
851 
852  virtual double GetMinimum( int nXSize, int nYSize, int *pbSuccess ) override;
853  virtual double GetMaximum( int nXSize, int nYSize, int *pbSuccess ) override;
854  virtual CPLErr ComputeRasterMinMax( int nXSize, int nYSize, int bApproxOK,
855  double* adfMinMax ) override;
856  virtual CPLErr ComputeStatistics( int nXSize, int nYSize,
857  int bApproxOK,
858  double *pdfMin, double *pdfMax,
859  double *pdfMean, double *pdfStdDev,
860  GDALProgressFunc pfnProgress,
861  void *pProgressData ) override;
862  virtual CPLErr GetHistogram( int nXSize, int nYSize,
863  double dfMin, double dfMax,
864  int nBuckets, GUIntBig * panHistogram,
865  int bIncludeOutOfRange, int bApproxOK,
866  GDALProgressFunc pfnProgress,
867  void *pProgressData ) override;
868 
869  void DstToSrc( double dfX, double dfY,
870  double &dfXOut, double &dfYOut ) const;
871  void SrcToDst( double dfX, double dfY,
872  double &dfXOut, double &dfYOut ) const;
873 
874  virtual void GetFileList( char*** ppapszFileList, int *pnSize,
875  int *pnMaxSize, CPLHashSet* hSetFiles ) override;
876 
877  virtual int IsSimpleSource() override { return TRUE; }
878  virtual const char* GetType() { return "SimpleSource"; }
879  virtual CPLErr FlushCache() override;
880 
881  GDALRasterBand* GetBand();
882  int IsSameExceptBandNumber( VRTSimpleSource* poOtherSource );
883  CPLErr DatasetRasterIO(
884  GDALDataType eBandDataType,
885  int nXOff, int nYOff, int nXSize, int nYSize,
886  void * pData, int nBufXSize, int nBufYSize,
887  GDALDataType eBufType,
888  int nBandCount, int *panBandMap,
889  GSpacing nPixelSpace, GSpacing nLineSpace,
890  GSpacing nBandSpace,
891  GDALRasterIOExtraArg* psExtraArg );
892 
893  void UnsetPreservedRelativeFilenames();
894 
895  void SetMaxValue( int nVal ) { m_nMaxValue = nVal; }
896 };
897 
898 /************************************************************************/
899 /* VRTAveragedSource */
900 /************************************************************************/
901 
902 class VRTAveragedSource : public VRTSimpleSource
903 {
904 public:
905  VRTAveragedSource();
906  virtual CPLErr RasterIO( GDALDataType eBandDataType,
907  int nXOff, int nYOff, int nXSize, int nYSize,
908  void *pData, int nBufXSize, int nBufYSize,
909  GDALDataType eBufType,
910  GSpacing nPixelSpace, GSpacing nLineSpace,
911  GDALRasterIOExtraArg* psExtraArgIn ) override;
912 
913  virtual double GetMinimum( int nXSize, int nYSize, int *pbSuccess ) override;
914  virtual double GetMaximum( int nXSize, int nYSize, int *pbSuccess ) override;
915  virtual CPLErr ComputeRasterMinMax( int nXSize, int nYSize, int bApproxOK,
916  double* adfMinMax ) override;
917  virtual CPLErr ComputeStatistics( int nXSize, int nYSize,
918  int bApproxOK,
919  double *pdfMin, double *pdfMax,
920  double *pdfMean, double *pdfStdDev,
921  GDALProgressFunc pfnProgress,
922  void *pProgressData ) override;
923  virtual CPLErr GetHistogram( int nXSize, int nYSize,
924  double dfMin, double dfMax,
925  int nBuckets, GUIntBig * panHistogram,
926  int bIncludeOutOfRange, int bApproxOK,
927  GDALProgressFunc pfnProgress,
928  void *pProgressData ) override;
929 
930  virtual CPLXMLNode *SerializeToXML( const char *pszVRTPath ) override;
931  virtual const char* GetType() override { return "AveragedSource"; }
932 };
933 
934 /************************************************************************/
935 /* VRTComplexSource */
936 /************************************************************************/
937 
938 typedef enum
939 {
940  VRT_SCALING_NONE,
941  VRT_SCALING_LINEAR,
942  VRT_SCALING_EXPONENTIAL,
943 } VRTComplexSourceScaling;
944 
945 class CPL_DLL VRTComplexSource : public VRTSimpleSource
946 {
947 protected:
948  VRTComplexSourceScaling m_eScalingType;
949  double m_dfScaleOff; // For linear scaling.
950  double m_dfScaleRatio; // For linear scaling.
951 
952  // For non-linear scaling with a power function.
953  int m_bSrcMinMaxDefined;
954  double m_dfSrcMin;
955  double m_dfSrcMax;
956  double m_dfDstMin;
957  double m_dfDstMax;
958  double m_dfExponent;
959 
960  int m_nColorTableComponent;
961 
962  template <class WorkingDT>
963  CPLErr RasterIOInternal( int nReqXOff, int nReqYOff,
964  int nReqXSize, int nReqYSize,
965  void *pData, int nOutXSize, int nOutYSize,
966  GDALDataType eBufType,
967  GSpacing nPixelSpace, GSpacing nLineSpace,
968  GDALRasterIOExtraArg* psExtraArg,
969  GDALDataType eWrkDataType );
970 
971 public:
972  VRTComplexSource();
973  VRTComplexSource(const VRTComplexSource* poSrcSource,
974  double dfXDstRatio, double dfYDstRatio);
975  virtual ~VRTComplexSource();
976 
977  virtual CPLErr RasterIO( GDALDataType eBandDataType,
978  int nXOff, int nYOff, int nXSize, int nYSize,
979  void *pData, int nBufXSize, int nBufYSize,
980  GDALDataType eBufType,
981  GSpacing nPixelSpace, GSpacing nLineSpace,
982  GDALRasterIOExtraArg* psExtraArgIn ) override;
983 
984  virtual double GetMinimum( int nXSize, int nYSize, int *pbSuccess ) override;
985  virtual double GetMaximum( int nXSize, int nYSize, int *pbSuccess ) override;
986  virtual CPLErr ComputeRasterMinMax( int nXSize, int nYSize, int bApproxOK,
987  double* adfMinMax ) override;
988  virtual CPLErr ComputeStatistics( int nXSize, int nYSize,
989  int bApproxOK,
990  double *pdfMin, double *pdfMax,
991  double *pdfMean, double *pdfStdDev,
992  GDALProgressFunc pfnProgress,
993  void *pProgressData ) override;
994  virtual CPLErr GetHistogram( int nXSize, int nYSize,
995  double dfMin, double dfMax,
996  int nBuckets, GUIntBig * panHistogram,
997  int bIncludeOutOfRange, int bApproxOK,
998  GDALProgressFunc pfnProgress,
999  void *pProgressData ) override;
1000 
1001  virtual CPLXMLNode *SerializeToXML( const char *pszVRTPath ) override;
1002  virtual CPLErr XMLInit( CPLXMLNode *, const char *, void* ) override;
1003  virtual const char* GetType() override { return "ComplexSource"; }
1004 
1005  double LookupValue( double dfInput );
1006 
1007  void SetLinearScaling( double dfOffset, double dfScale );
1008  void SetPowerScaling( double dfExponent,
1009  double dfSrcMin,
1010  double dfSrcMax,
1011  double dfDstMin,
1012  double dfDstMax );
1013  void SetColorTableComponent( int nComponent );
1014 
1015  double *m_padfLUTInputs;
1016  double *m_padfLUTOutputs;
1017  int m_nLUTItemCount;
1018 };
1019 
1020 /************************************************************************/
1021 /* VRTFilteredSource */
1022 /************************************************************************/
1023 
1024 class VRTFilteredSource : public VRTComplexSource
1025 {
1026 private:
1027  int IsTypeSupported( GDALDataType eTestType ) const;
1028 
1029 protected:
1030  int m_nSupportedTypesCount;
1031  GDALDataType m_aeSupportedTypes[20];
1032 
1033  int m_nExtraEdgePixels;
1034 
1035 public:
1036  VRTFilteredSource();
1037  virtual ~VRTFilteredSource();
1038 
1039  void SetExtraEdgePixels( int );
1040  void SetFilteringDataTypesSupported( int, GDALDataType * );
1041 
1042  virtual CPLErr FilterData( int nXSize, int nYSize, GDALDataType eType,
1043  GByte *pabySrcData, GByte *pabyDstData ) = 0;
1044 
1045  virtual CPLErr RasterIO( GDALDataType eBandDataType,
1046  int nXOff, int nYOff, int nXSize, int nYSize,
1047  void *pData, int nBufXSize, int nBufYSize,
1048  GDALDataType eBufType,
1049  GSpacing nPixelSpace, GSpacing nLineSpace,
1050  GDALRasterIOExtraArg* psExtraArg ) override;
1051 };
1052 
1053 /************************************************************************/
1054 /* VRTKernelFilteredSource */
1055 /************************************************************************/
1056 
1057 class VRTKernelFilteredSource : public VRTFilteredSource
1058 {
1059 protected:
1060  int m_nKernelSize;
1061 
1062  bool m_bSeparable;
1063 
1064  double *m_padfKernelCoefs;
1065 
1066  int m_bNormalized;
1067 
1068 public:
1069  VRTKernelFilteredSource();
1070  virtual ~VRTKernelFilteredSource();
1071 
1072  virtual CPLErr XMLInit( CPLXMLNode *psTree, const char *, void* ) override;
1073  virtual CPLXMLNode *SerializeToXML( const char *pszVRTPath ) override;
1074 
1075  virtual CPLErr FilterData( int nXSize, int nYSize, GDALDataType eType,
1076  GByte *pabySrcData, GByte *pabyDstData ) override;
1077 
1078  CPLErr SetKernel( int nKernelSize, bool bSeparable, double *padfCoefs );
1079  void SetNormalized( int );
1080 };
1081 
1082 /************************************************************************/
1083 /* VRTAverageFilteredSource */
1084 /************************************************************************/
1085 
1086 class VRTAverageFilteredSource : public VRTKernelFilteredSource
1087 {
1088 public:
1089  explicit VRTAverageFilteredSource( int nKernelSize );
1090  virtual ~VRTAverageFilteredSource();
1091 
1092  virtual CPLErr XMLInit( CPLXMLNode *psTree, const char *, void* ) override;
1093  virtual CPLXMLNode *SerializeToXML( const char *pszVRTPath ) override;
1094 };
1095 
1096 /************************************************************************/
1097 /* VRTFuncSource */
1098 /************************************************************************/
1099 class VRTFuncSource : public VRTSource
1100 {
1101 public:
1102  VRTFuncSource();
1103  virtual ~VRTFuncSource();
1104 
1105  virtual CPLErr XMLInit( CPLXMLNode *, const char *, void* ) override { return CE_Failure; }
1106  virtual CPLXMLNode *SerializeToXML( const char *pszVRTPath ) override;
1107 
1108  virtual CPLErr RasterIO( GDALDataType eBandDataType,
1109  int nXOff, int nYOff, int nXSize, int nYSize,
1110  void *pData, int nBufXSize, int nBufYSize,
1111  GDALDataType eBufType,
1112  GSpacing nPixelSpace, GSpacing nLineSpace,
1113  GDALRasterIOExtraArg* psExtraArg ) override;
1114 
1115  virtual double GetMinimum( int nXSize, int nYSize, int *pbSuccess ) override;
1116  virtual double GetMaximum( int nXSize, int nYSize, int *pbSuccess ) override;
1117  virtual CPLErr ComputeRasterMinMax( int nXSize, int nYSize, int bApproxOK,
1118  double* adfMinMax ) override;
1119  virtual CPLErr ComputeStatistics( int nXSize, int nYSize,
1120  int bApproxOK,
1121  double *pdfMin, double *pdfMax,
1122  double *pdfMean, double *pdfStdDev,
1123  GDALProgressFunc pfnProgress,
1124  void *pProgressData ) override;
1125  virtual CPLErr GetHistogram( int nXSize, int nYSize,
1126  double dfMin, double dfMax,
1127  int nBuckets, GUIntBig * panHistogram,
1128  int bIncludeOutOfRange, int bApproxOK,
1129  GDALProgressFunc pfnProgress,
1130  void *pProgressData ) override;
1131 
1132  VRTImageReadFunc pfnReadFunc;
1133  void *pCBData;
1134  GDALDataType eType;
1135 
1136  float fNoDataValue;
1137 };
1138 
1139 #endif /* #ifndef DOXYGEN_SKIP */
1140 
1141 #endif /* ndef VIRTUALDATASET_H_INCLUDED */
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
The GDALRasterAttributeTable (or RAT) class is used to encapsulate a table used to provide attribute ...
Definition: gdal_rat.h:47
virtual CPLErr GetGeoTransform(double *padfTransform)
Fetch the affine transformation coefficients.
Definition: gdaldataset.cpp:954
GDALDataType
Definition: gdal.h:60
virtual CPLErr SetCategoryNames(char **papszNames)
Set the category names for this band.
Definition: gdalrasterband.cpp:1579
Document node structure.
Definition: cpl_minixml.h:66
virtual GDALRasterBand * GetMaskBand()
Return the mask band associated with the band.
Definition: gdalrasterband.cpp:5880
virtual CPLErr AddBand(GDALDataType eType, char **papszOptions=nullptr)
Add a band to a dataset.
Definition: gdaldataset.cpp:580
virtual char ** GetCategoryNames()
Fetch the list of category names for this raster.
Definition: gdalrasterband.cpp:1531
virtual void SetDescription(const char *)
Set object description.
Definition: gdalmajorobject.cpp:120
virtual void FlushCache(void)
Flush all write cached data to disk.
Definition: gdaldataset.cpp:428
virtual GDALRasterBand * GetOverview(int)
Fetch overview raster band object.
Definition: gdalrasterband.cpp:2242
virtual CPLErr GetDefaultHistogram(double *pdfMin, double *pdfMax, int *pnBuckets, GUIntBig **ppanHistogram, int bForce, GDALProgressFunc, void *pProgressData)
Fetch default raster histogram.
Definition: gdalrasterband.cpp:3468
C++ GDAL entry points.
virtual CPLErr AdviseRead(int nXOff, int nYOff, int nXSize, int nYSize, int nBufXSize, int nBufYSize, GDALDataType eDT, int nBandCount, int *panBandList, char **papszOptions)
Advise driver of upcoming read requests.
Definition: gdaldataset.cpp:2295
virtual GDALColorInterp GetColorInterpretation()
How should this band be interpreted as color?
Definition: gdalrasterband.cpp:1974
virtual const char * GetProjectionRef(void)
Fetch the projection definition string for this dataset.
Definition: gdaldataset.cpp:856
virtual CPLErr SetDefaultRAT(const GDALRasterAttributeTable *poRAT)
Set default Raster Attribute Table.
Definition: gdalrasterband.cpp:5798
GDALRWFlag
Definition: gdal.h:119
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
unsigned char GByte
Unsigned byte type.
Definition: cpl_port.h:213
virtual int GetMaskFlags()
Return the status flags of the mask band associated with the band.
Definition: gdalrasterband.cpp:6127
void * GDALRasterBandH
Opaque type used for the C bindings of the C++ GDALRasterBand class.
Definition: gdal.h:258
virtual GDALRasterAttributeTable * GetDefaultRAT()
Fetch default Raster Attribute Table.
Definition: gdalrasterband.cpp:5750
virtual CPLErr GetHistogram(double dfMin, double dfMax, int nBuckets, GUIntBig *panHistogram, int bIncludeOutOfRange, int bApproxOK, GDALProgressFunc, void *pProgressData)
Compute raster histogram.
Definition: gdalrasterband.cpp:2921
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
virtual CPLErr SetGCPs(int nGCPCount, const GDAL_GCP *pasGCPList, const char *pszGCPProjection)
Assign GCPs.
Definition: gdaldataset.cpp:1414
virtual CPLErr SetOffset(double dfNewOffset)
Set scaling offset.
Definition: gdalrasterband.cpp:2490
CPLErr SetMetadata(char **papszMetadata, const char *pszDomain) override
Set metadata.
void char ** GetMetadata(const char *pszDomain="") override
Fetch metadata.
Definition: gdaldataset.cpp:3484
CPLErr SetMetadataItem(const char *pszName, const char *pszValue, const char *pszDomain) override
Set single metadata item.
#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
virtual CPLErr SetDefaultHistogram(double dfMin, double dfMax, int nBuckets, GUIntBig *panHistogram)
Set default histogram.
Definition: gdalrasterband.cpp:5651
int Dereference()
Subtract one from dataset reference count.
Definition: gdaldataset.cpp:1162
virtual double GetScale(int *pbSuccess=nullptr)
Fetch the raster value scale.
Definition: gdalrasterband.cpp:2547
virtual const GDAL_GCP * GetGCPs()
Fetch GCPs.
Definition: gdaldataset.cpp:1364
static GDALDataset * Open(const char *pszFilename, unsigned int nOpenFlags=0, const char *const *papszAllowedDrivers=nullptr, const char *const *papszOpenOptions=nullptr, const char *const *papszSiblingFiles=nullptr)
Definition: gdal_priv.h:614
virtual CPLErr DeleteNoDataValue()
Remove the no data value for this band.
Definition: gdalrasterband.cpp:1744
virtual CPLErr SetGeoTransform(double *padfTransform)
Set the affine transformation coefficients.
Definition: gdaldataset.cpp:1009
virtual double GetNoDataValue(int *pbSuccess=nullptr)
Fetch the no data value for this band.
Definition: gdalrasterband.cpp:1631
virtual int GetGCPCount()
Get number of GCPs.
Definition: gdaldataset.cpp:1296
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
virtual CPLErr SetColorInterpretation(GDALColorInterp eColorInterp)
Set color interpretation of a band.
Definition: gdalrasterband.cpp:2019
Structure to pass extra arguments to RasterIO() method.
Definition: gdal.h:147
virtual const char * GetUnitType()
Return raster unit type.
Definition: gdalrasterband.cpp:2643
High level image warping class.
Definition: gdalwarper.h:438
virtual CPLErr SetColorTable(GDALColorTable *poCT)
Set the raster color table.
Definition: gdalrasterband.cpp:2115
virtual GDALColorTable * GetColorTable()
Fetch the color table associated with band.
Definition: gdalrasterband.cpp:2066
virtual int CloseDependentDatasets()
Drop references to any other datasets referenced by this dataset.
Definition: gdaldataset.cpp:3432
virtual CPLErr CreateMaskBand(int nFlagsIn)
Adds a mask band to the dataset.
Definition: gdaldataset.cpp:2477
unsigned long long GUIntBig
Large unsigned integer type (generally 64-bit unsigned integer type).
Definition: cpl_port.h:249
virtual char ** GetFileList(void)
Fetch files forming dataset.
Definition: gdaldataset.cpp:2377
virtual CPLErr SetProjection(const char *pszProjection)
Set the projection reference string for this dataset.
Definition: gdaldataset.cpp:896
virtual const char * GetGCPProjection()
Get output projection for GCPs.
Definition: gdaldataset.cpp:1331
void GDALClose(GDALDatasetH)
Close GDAL dataset.
Definition: gdaldataset.cpp:3059
virtual CPLErr SetScale(double dfNewScale)
Set scaling ratio.
Definition: gdalrasterband.cpp:2596
virtual double GetOffset(int *pbSuccess=nullptr)
Fetch the raster value offset.
Definition: gdalrasterband.cpp:2441
Object with metadata.
Definition: gdal_priv.h:132
virtual int GetOverviewCount()
Return the number of overview layers available.
Definition: gdalrasterband.cpp:2200
GDALDataset * GetDataset()
Fetch the owning dataset handle.
Definition: gdalrasterband.cpp:2853
CPLErr SetMetadataItem(const char *pszName, const char *pszValue, const char *pszDomain) override
Set single metadata item.
GUIntBig vsi_l_offset
Type for a file offset.
Definition: cpl_vsi.h:139
virtual CPLErr SetUnitType(const char *pszNewValue)
Set unit type.
Definition: gdalrasterband.cpp:2691
A single raster band (or channel).
Definition: gdal_priv.h:1042
GDALAccess
Definition: gdal.h:113
virtual CPLErr CreateMaskBand(int nFlagsIn)
Adds a mask band to the current band.
Definition: gdalrasterband.cpp:6208
A set of associated raster bands, usually from one file.
Definition: gdal_priv.h:339
CPLErr SetMetadata(char **papszMetadata, const char *pszDomain) override
Set metadata.
GDALColorInterp
Definition: gdal.h:190
virtual CPLErr SetNoDataValue(double dfNoData)
Set the no data value for this band.
Definition: gdalrasterband.cpp:1690
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
int GetShared() const
Returns shared flag.
Definition: gdaldataset.cpp:1234
Definition: gdal.h:114
Format specific driver.
Definition: gdal_priv.h:1386
A color table / palette.
Definition: gdal_priv.h:949
Ground Control Point.
Definition: gdal.h:560
CPLErr
Error category.
Definition: cpl_error.h:52
#define CPL_DISALLOW_COPY_ASSIGN(ClassName)
Helper to remove the copy and assignment constructors so that the compiler will not generate the defa...
Definition: cpl_port.h:987

Generated for GDAL by doxygen 1.8.8.