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