1 : /******************************************************************************
2 : * $Id: vrtdataset.h 24183 2012-03-31 16:40:56Z 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 : *
11 : * Permission is hereby granted, free of charge, to any person obtaining a
12 : * copy of this software and associated documentation files (the "Software"),
13 : * to deal in the Software without restriction, including without limitation
14 : * the rights to use, copy, modify, merge, publish, distribute, sublicense,
15 : * and/or sell copies of the Software, and to permit persons to whom the
16 : * Software is furnished to do so, subject to the following conditions:
17 : *
18 : * The above copyright notice and this permission notice shall be included
19 : * in all copies or substantial portions of the Software.
20 : *
21 : * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
22 : * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
23 : * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
24 : * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
25 : * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
26 : * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
27 : * DEALINGS IN THE SOFTWARE.
28 : ****************************************************************************/
29 :
30 : #ifndef VIRTUALDATASET_H_INCLUDED
31 : #define VIRTUALDATASET_H_INCLUDED
32 :
33 : #include "gdal_priv.h"
34 : #include "gdal_pam.h"
35 : #include "gdal_vrt.h"
36 : #include "cpl_hash_set.h"
37 :
38 : int VRTApplyMetadata( CPLXMLNode *, GDALMajorObject * );
39 : CPLXMLNode *VRTSerializeMetadata( GDALMajorObject * );
40 :
41 : int VRTWarpedOverviewTransform( void *pTransformArg, int bDstToSrc,
42 : int nPointCount,
43 : double *padfX, double *padfY, double *padfZ,
44 : int *panSuccess );
45 : void* VRTDeserializeWarpedOverviewTransformer( CPLXMLNode *psTree );
46 :
47 : /************************************************************************/
48 : /* VRTOverviewInfo() */
49 : /************************************************************************/
50 : class VRTOverviewInfo
51 12 : {
52 : public:
53 : CPLString osFilename;
54 : int nBand;
55 : GDALRasterBand *poBand;
56 : int bTriedToOpen;
57 :
58 12 : VRTOverviewInfo() : poBand(NULL), bTriedToOpen(FALSE) {}
59 24 : ~VRTOverviewInfo() {
60 24 : if( poBand == NULL )
61 : /* do nothing */;
62 8 : else if( poBand->GetDataset()->GetShared() )
63 8 : GDALClose( (GDALDatasetH) poBand->GetDataset() );
64 : else
65 0 : poBand->GetDataset()->Dereference();
66 24 : }
67 : };
68 :
69 :
70 : /************************************************************************/
71 : /* VRTSource */
72 : /************************************************************************/
73 :
74 : class VRTSource
75 1294 : {
76 : public:
77 : virtual ~VRTSource();
78 :
79 : virtual CPLErr RasterIO( int nXOff, int nYOff, int nXSize, int nYSize,
80 : void *pData, int nBufXSize, int nBufYSize,
81 : GDALDataType eBufType,
82 : int nPixelSpace, int nLineSpace ) = 0;
83 :
84 : virtual double GetMinimum( int nXSize, int nYSize, int *pbSuccess ) = 0;
85 : virtual double GetMaximum( int nXSize, int nYSize, int *pbSuccess ) = 0;
86 :
87 : virtual CPLErr XMLInit( CPLXMLNode *psTree, const char * ) = 0;
88 : virtual CPLXMLNode *SerializeToXML( const char *pszVRTPath ) = 0;
89 :
90 : virtual void GetFileList(char*** ppapszFileList, int *pnSize,
91 : int *pnMaxSize, CPLHashSet* hSetFiles);
92 :
93 0 : virtual int IsSimpleSource() { return FALSE; }
94 : };
95 :
96 : typedef VRTSource *(*VRTSourceParser)(CPLXMLNode *, const char *);
97 :
98 : VRTSource *VRTParseCoreSources( CPLXMLNode *psTree, const char * );
99 : VRTSource *VRTParseFilterSources( CPLXMLNode *psTree, const char * );
100 :
101 : /************************************************************************/
102 : /* VRTDataset */
103 : /************************************************************************/
104 :
105 : class VRTRasterBand;
106 :
107 : class CPL_DLL VRTDataset : public GDALDataset
108 : {
109 : friend class VRTRasterBand;
110 :
111 : char *pszProjection;
112 :
113 : int bGeoTransformSet;
114 : double adfGeoTransform[6];
115 :
116 : int nGCPCount;
117 : GDAL_GCP *pasGCPList;
118 : char *pszGCPProjection;
119 :
120 : int bNeedsFlush;
121 : int bWritable;
122 :
123 : char *pszVRTPath;
124 :
125 : VRTRasterBand *poMaskBand;
126 :
127 : int bCompatibleForDatasetIO;
128 : int CheckCompatibleForDatasetIO();
129 :
130 : protected:
131 : virtual int CloseDependentDatasets();
132 :
133 : public:
134 : VRTDataset(int nXSize, int nYSize);
135 : ~VRTDataset();
136 :
137 8554 : void SetNeedsFlush() { bNeedsFlush = TRUE; }
138 : virtual void FlushCache();
139 :
140 : void SetWritable(int bWritable) { this->bWritable = bWritable; }
141 :
142 : virtual CPLErr CreateMaskBand( int nFlags );
143 : void SetMaskBand(VRTRasterBand* poMaskBand);
144 :
145 : virtual const char *GetProjectionRef(void);
146 : virtual CPLErr SetProjection( const char * );
147 : virtual CPLErr GetGeoTransform( double * );
148 : virtual CPLErr SetGeoTransform( double * );
149 :
150 : virtual CPLErr SetMetadata( char **papszMD, const char *pszDomain = "" );
151 : virtual CPLErr SetMetadataItem( const char *pszName, const char *pszValue,
152 : const char *pszDomain = "" );
153 :
154 : virtual int GetGCPCount();
155 : virtual const char *GetGCPProjection();
156 : virtual const GDAL_GCP *GetGCPs();
157 : virtual CPLErr SetGCPs( int nGCPCount, const GDAL_GCP *pasGCPList,
158 : const char *pszGCPProjection );
159 :
160 : virtual CPLErr AddBand( GDALDataType eType,
161 : char **papszOptions=NULL );
162 :
163 : virtual char **GetFileList();
164 :
165 : virtual CPLErr IRasterIO( GDALRWFlag eRWFlag,
166 : int nXOff, int nYOff, int nXSize, int nYSize,
167 : void * pData, int nBufXSize, int nBufYSize,
168 : GDALDataType eBufType,
169 : int nBandCount, int *panBandMap,
170 : int nPixelSpace, int nLineSpace, int nBandSpace);
171 :
172 : virtual CPLXMLNode *SerializeToXML( const char *pszVRTPath);
173 : virtual CPLErr XMLInit( CPLXMLNode *, const char * );
174 :
175 : /* Used by PDF driver for example */
176 : GDALDataset* GetSingleSimpleSource();
177 :
178 : static int Identify( GDALOpenInfo * );
179 : static GDALDataset *Open( GDALOpenInfo * );
180 : static GDALDataset *OpenXML( const char *, const char * = NULL, GDALAccess eAccess = GA_ReadOnly );
181 : static GDALDataset *Create( const char * pszName,
182 : int nXSize, int nYSize, int nBands,
183 : GDALDataType eType, char ** papszOptions );
184 : static CPLErr Delete( const char * pszFilename );
185 : };
186 :
187 : /************************************************************************/
188 : /* VRTWarpedDataset */
189 : /************************************************************************/
190 :
191 : class GDALWarpOperation;
192 : class VRTWarpedRasterBand;
193 :
194 : class CPL_DLL VRTWarpedDataset : public VRTDataset
195 : {
196 : int nBlockXSize;
197 : int nBlockYSize;
198 : GDALWarpOperation *poWarper;
199 :
200 : friend class VRTWarpedRasterBand;
201 :
202 : protected:
203 : virtual int CloseDependentDatasets();
204 :
205 : public:
206 : int nOverviewCount;
207 : VRTWarpedDataset **papoOverviews;
208 :
209 : public:
210 : VRTWarpedDataset( int nXSize, int nYSize );
211 : ~VRTWarpedDataset();
212 :
213 : CPLErr Initialize( /* GDALWarpOptions */ void * );
214 :
215 : virtual CPLErr IBuildOverviews( const char *, int, int *,
216 : int, int *, GDALProgressFunc, void * );
217 :
218 : virtual CPLXMLNode *SerializeToXML( const char *pszVRTPath );
219 : virtual CPLErr XMLInit( CPLXMLNode *, const char * );
220 :
221 : virtual CPLErr AddBand( GDALDataType eType,
222 : char **papszOptions=NULL );
223 :
224 : virtual char **GetFileList();
225 :
226 : CPLErr ProcessBlock( int iBlockX, int iBlockY );
227 :
228 : void GetBlockSize( int *, int * );
229 : };
230 :
231 : /************************************************************************/
232 : /* VRTRasterBand */
233 : /* */
234 : /* Provides support for all the various kinds of metadata but */
235 : /* no raster access. That is handled by derived classes. */
236 : /************************************************************************/
237 :
238 : class CPL_DLL VRTRasterBand : public GDALRasterBand
239 : {
240 : protected:
241 : int bIsMaskBand;
242 :
243 : int bNoDataValueSet;
244 : int bHideNoDataValue; // If set to true, will not report the existance of nodata
245 : double dfNoDataValue;
246 :
247 : GDALColorTable *poColorTable;
248 :
249 : GDALColorInterp eColorInterp;
250 :
251 : char *pszUnitType;
252 : char **papszCategoryNames;
253 :
254 : double dfOffset;
255 : double dfScale;
256 :
257 : CPLXMLNode *psSavedHistograms;
258 :
259 : void Initialize( int nXSize, int nYSize );
260 :
261 : std::vector<VRTOverviewInfo> apoOverviews;
262 :
263 : VRTRasterBand *poMaskBand;
264 :
265 : public:
266 :
267 : VRTRasterBand();
268 : virtual ~VRTRasterBand();
269 :
270 : virtual CPLErr XMLInit( CPLXMLNode *, const char * );
271 : virtual CPLXMLNode * SerializeToXML( const char *pszVRTPath );
272 :
273 : virtual CPLErr SetNoDataValue( double );
274 : virtual double GetNoDataValue( int *pbSuccess = NULL );
275 :
276 : virtual CPLErr SetColorTable( GDALColorTable * );
277 : virtual GDALColorTable *GetColorTable();
278 :
279 : virtual CPLErr SetColorInterpretation( GDALColorInterp );
280 : virtual GDALColorInterp GetColorInterpretation();
281 :
282 : virtual const char *GetUnitType();
283 : CPLErr SetUnitType( const char * );
284 :
285 : virtual char **GetCategoryNames();
286 : virtual CPLErr SetCategoryNames( char ** );
287 :
288 : virtual CPLErr SetMetadata( char **papszMD, const char *pszDomain = "" );
289 : virtual CPLErr SetMetadataItem( const char *pszName, const char *pszValue,
290 : const char *pszDomain = "" );
291 :
292 : virtual double GetOffset( int *pbSuccess = NULL );
293 : CPLErr SetOffset( double );
294 : virtual double GetScale( int *pbSuccess = NULL );
295 : CPLErr SetScale( double );
296 :
297 : virtual int GetOverviewCount();
298 : virtual GDALRasterBand *GetOverview(int);
299 :
300 : virtual CPLErr GetHistogram( double dfMin, double dfMax,
301 : int nBuckets, int * panHistogram,
302 : int bIncludeOutOfRange, int bApproxOK,
303 : GDALProgressFunc, void *pProgressData );
304 :
305 : virtual CPLErr GetDefaultHistogram( double *pdfMin, double *pdfMax,
306 : int *pnBuckets, int ** ppanHistogram,
307 : int bForce,
308 : GDALProgressFunc, void *pProgressData);
309 :
310 : virtual CPLErr SetDefaultHistogram( double dfMin, double dfMax,
311 : int nBuckets, int *panHistogram );
312 :
313 : CPLErr CopyCommonInfoFrom( GDALRasterBand * );
314 :
315 : virtual void GetFileList(char*** ppapszFileList, int *pnSize,
316 : int *pnMaxSize, CPLHashSet* hSetFiles);
317 :
318 : virtual void SetDescription( const char * );
319 :
320 : virtual GDALRasterBand *GetMaskBand();
321 : virtual int GetMaskFlags();
322 :
323 : virtual CPLErr CreateMaskBand( int nFlags );
324 :
325 : void SetMaskBand(VRTRasterBand* poMaskBand);
326 :
327 : void SetIsMaskBand();
328 :
329 : CPLErr UnsetNoDataValue();
330 :
331 : virtual int CloseDependentDatasets();
332 :
333 50 : virtual int IsSourcedRasterBand() { return FALSE; }
334 : };
335 :
336 : /************************************************************************/
337 : /* VRTSourcedRasterBand */
338 : /************************************************************************/
339 :
340 : class CPL_DLL VRTSourcedRasterBand : public VRTRasterBand
341 : {
342 : private:
343 : int bAntiRecursionFlag;
344 : CPLString osLastLocationInfo;
345 :
346 : void Initialize( int nXSize, int nYSize );
347 :
348 : public:
349 : int nSources;
350 : VRTSource **papoSources;
351 : int bEqualAreas;
352 :
353 : VRTSourcedRasterBand( GDALDataset *poDS, int nBand );
354 : VRTSourcedRasterBand( GDALDataType eType,
355 : int nXSize, int nYSize );
356 : VRTSourcedRasterBand( GDALDataset *poDS, int nBand,
357 : GDALDataType eType,
358 : int nXSize, int nYSize );
359 : virtual ~VRTSourcedRasterBand();
360 :
361 : virtual CPLErr IRasterIO( GDALRWFlag, int, int, int, int,
362 : void *, int, int, GDALDataType,
363 : int, int );
364 :
365 : virtual const char *GetMetadataItem( const char * pszName,
366 : const char * pszDomain = "" );
367 : virtual char **GetMetadata( const char * pszDomain = "" );
368 : virtual CPLErr SetMetadata( char ** papszMetadata,
369 : const char * pszDomain = "" );
370 : virtual CPLErr SetMetadataItem( const char * pszName,
371 : const char * pszValue,
372 : const char * pszDomain = "" );
373 :
374 : virtual CPLErr XMLInit( CPLXMLNode *, const char * );
375 : virtual CPLXMLNode * SerializeToXML( const char *pszVRTPath );
376 :
377 : virtual double GetMinimum( int *pbSuccess = NULL );
378 : virtual double GetMaximum(int *pbSuccess = NULL );
379 :
380 : CPLErr AddSource( VRTSource * );
381 : CPLErr AddSimpleSource( GDALRasterBand *poSrcBand,
382 : int nSrcXOff=-1, int nSrcYOff=-1,
383 : int nSrcXSize=-1, int nSrcYSize=-1,
384 : int nDstXOff=-1, int nDstYOff=-1,
385 : int nDstXSize=-1, int nDstYSize=-1,
386 : const char *pszResampling = "near",
387 : double dfNoDataValue = VRT_NODATA_UNSET);
388 : CPLErr AddComplexSource( GDALRasterBand *poSrcBand,
389 : int nSrcXOff=-1, int nSrcYOff=-1,
390 : int nSrcXSize=-1, int nSrcYSize=-1,
391 : int nDstXOff=-1, int nDstYOff=-1,
392 : int nDstXSize=-1, int nDstYSize=-1,
393 : double dfScaleOff=0.0,
394 : double dfScaleRatio=1.0,
395 : double dfNoDataValue = VRT_NODATA_UNSET,
396 : int nColorTableComponent = 0);
397 :
398 : CPLErr AddMaskBandSource( GDALRasterBand *poSrcBand,
399 : int nSrcXOff=-1, int nSrcYOff=-1,
400 : int nSrcXSize=-1, int nSrcYSize=-1,
401 : int nDstXOff=-1, int nDstYOff=-1,
402 : int nDstXSize=-1, int nDstYSize=-1 );
403 :
404 : CPLErr AddFuncSource( VRTImageReadFunc pfnReadFunc, void *hCBData,
405 : double dfNoDataValue = VRT_NODATA_UNSET );
406 :
407 :
408 : virtual CPLErr IReadBlock( int, int, void * );
409 :
410 : virtual void GetFileList(char*** ppapszFileList, int *pnSize,
411 : int *pnMaxSize, CPLHashSet* hSetFiles);
412 :
413 : virtual int CloseDependentDatasets();
414 :
415 418 : virtual int IsSourcedRasterBand() { return TRUE; }
416 : };
417 :
418 : /************************************************************************/
419 : /* VRTWarpedRasterBand */
420 : /************************************************************************/
421 :
422 : class CPL_DLL VRTWarpedRasterBand : public VRTRasterBand
423 : {
424 : public:
425 : VRTWarpedRasterBand( GDALDataset *poDS, int nBand,
426 : GDALDataType eType = GDT_Unknown );
427 : virtual ~VRTWarpedRasterBand();
428 :
429 : virtual CPLErr XMLInit( CPLXMLNode *, const char * );
430 : virtual CPLXMLNode * SerializeToXML( const char *pszVRTPath );
431 :
432 : virtual CPLErr IReadBlock( int, int, void * );
433 : virtual CPLErr IWriteBlock( int, int, void * );
434 :
435 : virtual int GetOverviewCount();
436 : virtual GDALRasterBand *GetOverview(int);
437 : };
438 :
439 : /************************************************************************/
440 : /* VRTDerivedRasterBand */
441 : /************************************************************************/
442 :
443 : class CPL_DLL VRTDerivedRasterBand : public VRTSourcedRasterBand
444 : {
445 :
446 : public:
447 : char *pszFuncName;
448 : GDALDataType eSourceTransferType;
449 :
450 : VRTDerivedRasterBand(GDALDataset *poDS, int nBand);
451 : VRTDerivedRasterBand(GDALDataset *poDS, int nBand,
452 : GDALDataType eType, int nXSize, int nYSize);
453 : virtual ~VRTDerivedRasterBand();
454 :
455 : virtual CPLErr IRasterIO( GDALRWFlag, int, int, int, int,
456 : void *, int, int, GDALDataType,
457 : int, int );
458 :
459 : static CPLErr AddPixelFunction
460 : (const char *pszFuncName, GDALDerivedPixelFunc pfnPixelFunc);
461 : static GDALDerivedPixelFunc GetPixelFunction(const char *pszFuncName);
462 :
463 : void SetPixelFunctionName(const char *pszFuncName);
464 : void SetSourceTransferType(GDALDataType eDataType);
465 :
466 : virtual CPLErr XMLInit( CPLXMLNode *, const char * );
467 : virtual CPLXMLNode * SerializeToXML( const char *pszVRTPath );
468 :
469 : };
470 :
471 : /************************************************************************/
472 : /* VRTRawRasterBand */
473 : /************************************************************************/
474 :
475 : class RawRasterBand;
476 :
477 : class CPL_DLL VRTRawRasterBand : public VRTRasterBand
478 : {
479 : RawRasterBand *poRawRaster;
480 :
481 : char *pszSourceFilename;
482 : int bRelativeToVRT;
483 :
484 : public:
485 : VRTRawRasterBand( GDALDataset *poDS, int nBand,
486 : GDALDataType eType = GDT_Unknown );
487 : virtual ~VRTRawRasterBand();
488 :
489 : virtual CPLErr XMLInit( CPLXMLNode *, const char * );
490 : virtual CPLXMLNode * SerializeToXML( const char *pszVRTPath );
491 :
492 : virtual CPLErr IRasterIO( GDALRWFlag, int, int, int, int,
493 : void *, int, int, GDALDataType,
494 : int, int );
495 :
496 : virtual CPLErr IReadBlock( int, int, void * );
497 : virtual CPLErr IWriteBlock( int, int, void * );
498 :
499 : CPLErr SetRawLink( const char *pszFilename,
500 : const char *pszVRTPath,
501 : int bRelativeToVRT,
502 : vsi_l_offset nImageOffset,
503 : int nPixelOffset, int nLineOffset,
504 : const char *pszByteOrder );
505 :
506 : void ClearRawLink();
507 :
508 : virtual void GetFileList(char*** ppapszFileList, int *pnSize,
509 : int *pnMaxSize, CPLHashSet* hSetFiles);
510 : };
511 :
512 : /************************************************************************/
513 : /* VRTDriver */
514 : /************************************************************************/
515 :
516 : class VRTDriver : public GDALDriver
517 : {
518 : void *pDeserializerData;
519 :
520 : public:
521 : VRTDriver();
522 : ~VRTDriver();
523 :
524 : char **papszSourceParsers;
525 :
526 : virtual char **GetMetadata( const char * pszDomain = "" );
527 : virtual CPLErr SetMetadata( char ** papszMetadata,
528 : const char * pszDomain = "" );
529 :
530 : VRTSource *ParseSource( CPLXMLNode *psSrc, const char *pszVRTPath );
531 : void AddSourceParser( const char *pszElementName,
532 : VRTSourceParser pfnParser );
533 : };
534 :
535 : /************************************************************************/
536 : /* VRTSimpleSource */
537 : /************************************************************************/
538 :
539 : class VRTSimpleSource : public VRTSource
540 : {
541 : protected:
542 : GDALRasterBand *poRasterBand;
543 :
544 : /* when poRasterBand is a mask band, poMaskBandMainBand is the band */
545 : /* from which the mask band is taken */
546 : GDALRasterBand *poMaskBandMainBand;
547 :
548 : int nSrcXOff;
549 : int nSrcYOff;
550 : int nSrcXSize;
551 : int nSrcYSize;
552 :
553 : int nDstXOff;
554 : int nDstYOff;
555 : int nDstXSize;
556 : int nDstYSize;
557 :
558 : int bNoDataSet;
559 : double dfNoDataValue;
560 :
561 : public:
562 : VRTSimpleSource();
563 : virtual ~VRTSimpleSource();
564 :
565 : virtual CPLErr XMLInit( CPLXMLNode *psTree, const char * );
566 : virtual CPLXMLNode *SerializeToXML( const char *pszVRTPath );
567 :
568 : void SetSrcBand( GDALRasterBand * );
569 : void SetSrcMaskBand( GDALRasterBand * );
570 : void SetSrcWindow( int, int, int, int );
571 : void SetDstWindow( int, int, int, int );
572 : void SetNoDataValue( double dfNoDataValue );
573 :
574 : int GetSrcDstWindow( int, int, int, int, int, int,
575 : int *, int *, int *, int *,
576 : int *, int *, int *, int * );
577 :
578 : virtual CPLErr RasterIO( int nXOff, int nYOff, int nXSize, int nYSize,
579 : void *pData, int nBufXSize, int nBufYSize,
580 : GDALDataType eBufType,
581 : int nPixelSpace, int nLineSpace );
582 :
583 : virtual double GetMinimum( int nXSize, int nYSize, int *pbSuccess );
584 : virtual double GetMaximum( int nXSize, int nYSize, int *pbSuccess );
585 :
586 : void DstToSrc( double dfX, double dfY,
587 : double &dfXOut, double &dfYOut );
588 : void SrcToDst( double dfX, double dfY,
589 : double &dfXOut, double &dfYOut );
590 :
591 : virtual void GetFileList(char*** ppapszFileList, int *pnSize,
592 : int *pnMaxSize, CPLHashSet* hSetFiles);
593 :
594 316 : virtual int IsSimpleSource() { return TRUE; }
595 512 : virtual const char* GetType() { return "SimpleSource"; }
596 :
597 : GDALRasterBand* GetBand();
598 : int IsSameExceptBandNumber(VRTSimpleSource* poOtherSource);
599 : CPLErr DatasetRasterIO(
600 : int nXOff, int nYOff, int nXSize, int nYSize,
601 : void * pData, int nBufXSize, int nBufYSize,
602 : GDALDataType eBufType,
603 : int nBandCount, int *panBandMap,
604 : int nPixelSpace, int nLineSpace, int nBandSpace);
605 : };
606 :
607 : /************************************************************************/
608 : /* VRTAveragedSource */
609 : /************************************************************************/
610 :
611 : class VRTAveragedSource : public VRTSimpleSource
612 4 : {
613 : public:
614 : VRTAveragedSource();
615 : virtual CPLErr RasterIO( int nXOff, int nYOff, int nXSize, int nYSize,
616 : void *pData, int nBufXSize, int nBufYSize,
617 : GDALDataType eBufType,
618 : int nPixelSpace, int nLineSpace );
619 :
620 : virtual double GetMinimum( int nXSize, int nYSize, int *pbSuccess );
621 : virtual double GetMaximum( int nXSize, int nYSize, int *pbSuccess );
622 :
623 : virtual CPLXMLNode *SerializeToXML( const char *pszVRTPath );
624 0 : virtual const char* GetType() { return "AveragedSource"; }
625 : };
626 :
627 : /************************************************************************/
628 : /* VRTComplexSource */
629 : /************************************************************************/
630 :
631 : class VRTComplexSource : public VRTSimpleSource
632 : {
633 : public:
634 : VRTComplexSource();
635 : virtual ~VRTComplexSource();
636 :
637 : virtual CPLErr RasterIO( int nXOff, int nYOff, int nXSize, int nYSize,
638 : void *pData, int nBufXSize, int nBufYSize,
639 : GDALDataType eBufType,
640 : int nPixelSpace, int nLineSpace );
641 :
642 : virtual double GetMinimum( int nXSize, int nYSize, int *pbSuccess );
643 : virtual double GetMaximum( int nXSize, int nYSize, int *pbSuccess );
644 :
645 : virtual CPLXMLNode *SerializeToXML( const char *pszVRTPath );
646 : virtual CPLErr XMLInit( CPLXMLNode *, const char * );
647 18 : virtual const char* GetType() { return "ComplexSource"; }
648 :
649 : double LookupValue( double dfInput );
650 :
651 : int bDoScaling;
652 : double dfScaleOff;
653 : double dfScaleRatio;
654 : double *padfLUTInputs;
655 : double *padfLUTOutputs;
656 : int nLUTItemCount;
657 : int nColorTableComponent;
658 : };
659 :
660 : /************************************************************************/
661 : /* VRTFilteredSource */
662 : /************************************************************************/
663 :
664 : class VRTFilteredSource : public VRTComplexSource
665 : {
666 : private:
667 : int IsTypeSupported( GDALDataType eType );
668 :
669 : protected:
670 : int nSupportedTypesCount;
671 : GDALDataType aeSupportedTypes[20];
672 :
673 : int nExtraEdgePixels;
674 :
675 : public:
676 : VRTFilteredSource();
677 : virtual ~VRTFilteredSource();
678 :
679 : void SetExtraEdgePixels( int );
680 : void SetFilteringDataTypesSupported( int, GDALDataType * );
681 :
682 : virtual CPLErr FilterData( int nXSize, int nYSize, GDALDataType eType,
683 : GByte *pabySrcData, GByte *pabyDstData ) = 0;
684 :
685 : virtual CPLErr RasterIO( int nXOff, int nYOff, int nXSize, int nYSize,
686 : void *pData, int nBufXSize, int nBufYSize,
687 : GDALDataType eBufType,
688 : int nPixelSpace, int nLineSpace );
689 : };
690 :
691 : /************************************************************************/
692 : /* VRTKernelFilteredSource */
693 : /************************************************************************/
694 :
695 : class VRTKernelFilteredSource : public VRTFilteredSource
696 : {
697 : protected:
698 : int nKernelSize;
699 :
700 : double *padfKernelCoefs;
701 :
702 : int bNormalized;
703 :
704 : public:
705 : VRTKernelFilteredSource();
706 : virtual ~VRTKernelFilteredSource();
707 :
708 : virtual CPLErr XMLInit( CPLXMLNode *psTree, const char * );
709 : virtual CPLXMLNode *SerializeToXML( const char *pszVRTPath );
710 :
711 : virtual CPLErr FilterData( int nXSize, int nYSize, GDALDataType eType,
712 : GByte *pabySrcData, GByte *pabyDstData );
713 :
714 : CPLErr SetKernel( int nKernelSize, double *padfCoefs );
715 : void SetNormalized( int );
716 : };
717 :
718 : /************************************************************************/
719 : /* VRTAverageFilteredSource */
720 : /************************************************************************/
721 :
722 : class VRTAverageFilteredSource : public VRTKernelFilteredSource
723 : {
724 : public:
725 : VRTAverageFilteredSource( int nKernelSize );
726 : virtual ~VRTAverageFilteredSource();
727 :
728 : virtual CPLErr XMLInit( CPLXMLNode *psTree, const char * );
729 : virtual CPLXMLNode *SerializeToXML( const char *pszVRTPath );
730 : };
731 :
732 : /************************************************************************/
733 : /* VRTFuncSource */
734 : /************************************************************************/
735 : class VRTFuncSource : public VRTSource
736 : {
737 : public:
738 : VRTFuncSource();
739 : virtual ~VRTFuncSource();
740 :
741 0 : virtual CPLErr XMLInit( CPLXMLNode *, const char *) { return CE_Failure; }
742 : virtual CPLXMLNode *SerializeToXML( const char *pszVRTPath );
743 :
744 : virtual CPLErr RasterIO( int nXOff, int nYOff, int nXSize, int nYSize,
745 : void *pData, int nBufXSize, int nBufYSize,
746 : GDALDataType eBufType,
747 : int nPixelSpace, int nLineSpace );
748 :
749 : virtual double GetMinimum( int nXSize, int nYSize, int *pbSuccess );
750 : virtual double GetMaximum( int nXSize, int nYSize, int *pbSuccess );
751 :
752 : VRTImageReadFunc pfnReadFunc;
753 : void *pCBData;
754 : GDALDataType eType;
755 :
756 : float fNoDataValue;
757 : };
758 :
759 : #endif /* ndef VIRTUALDATASET_H_INCLUDED */
|
