- Main Page
- Related Pages
- Classes
- Files

- File List
- File Members

# gdalwarper.h

Go to the documentation of this file.

    00001 /******************************************************************************
    00002  * $Id: gdalwarper.h 29330 2015-06-14 12:11:11Z rouault $
    00003  *
    00004  * Project:  GDAL High Performance Warper
    00005  * Purpose:  Prototypes, and definitions for warping related work.
    00006  * Author:   Frank Warmerdam, warmerdam@pobox.com
    00007  *
    00008  ******************************************************************************
    00009  * Copyright (c) 2003, Frank Warmerdam
    00010  * Copyright (c) 2009-2012, Even Rouault <even dot rouault at mines-paris dot org>
    00011  *
    00012  * Permission is hereby granted, free of charge, to any person obtaining a
    00013  * copy of this software and associated documentation files (the "Software"),
    00014  * to deal in the Software without restriction, including without limitation
    00015  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
    00016  * and/or sell copies of the Software, and to permit persons to whom the
    00017  * Software is furnished to do so, subject to the following conditions:
    00018  *
    00019  * The above copyright notice and this permission notice shall be included
    00020  * in all copies or substantial portions of the Software.
    00021  *
    00022  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
    00023  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    00024  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
    00025  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    00026  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
    00027  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
    00028  * DEALINGS IN THE SOFTWARE.
    00029  ****************************************************************************/
    00030
    00031 #ifndef GDALWARPER_H_INCLUDED
    00032 #define GDALWARPER_H_INCLUDED
    00033
    00042 #include "gdal_alg.h"
    00043 #include "cpl_minixml.h"
    00044 #include "cpl_multiproc.h"
    00045
    00046 CPL_C_START
    00047
    00048 /* Note: values are selected to be consistent with GDALRIOResampleAlg of gcore/gdal.h */
    00050 typedef enum { GRA_NearestNeighbour=0,                         GRA_Bilinear=1,  GRA_Cubic=2,     GRA_CubicSpline=3, GRA_Lanczos=4, GRA_Average=5,  GRA_Mode=6,
    00058   // GRA_Gauss=7 reserved. GRA_Max=8, GRA_Min=9, GRA_Med=10, GRA_Q1=11, GRA_Q3=12
    00064 } GDALResampleAlg;
    00065
    00067 typedef enum { GWKAOM_Average=1, GWKAOM_Fmode=2, GWKAOM_Imode=3, GWKAOM_Max=4, GWKAOM_Min=5, GWKAOM_Quant=6
    00074 } GWKAverageOrModeAlg;
    00075
    00076 typedef int
    00077 (*GDALMaskFunc)( void *pMaskFuncArg,
    00078                  int nBandCount, GDALDataType eType,
    00079                  int nXOff, int nYOff,
    00080                  int nXSize, int nYSize,
    00081                  GByte **papabyImageData,
    00082                  int bMaskIsFloat, void *pMask );
    00083
    00084 CPLErr CPL_DLL
    00085 GDALWarpNoDataMasker( void *pMaskFuncArg, int nBandCount, GDALDataType eType,
    00086                       int nXOff, int nYOff, int nXSize, int nYSize,
    00087                       GByte **papabyImageData, int bMaskIsFloat,
    00088                       void *pValidityMask, int* pbOutAllValid );
    00089
    00090 CPLErr CPL_DLL
    00091 GDALWarpDstAlphaMasker( void *pMaskFuncArg, int nBandCount, GDALDataType eType,
    00092                         int nXOff, int nYOff, int nXSize, int nYSize,
    00093                         GByte ** /*ppImageData */,
    00094                         int bMaskIsFloat, void *pValidityMask );
    00095 CPLErr CPL_DLL
    00096 GDALWarpSrcAlphaMasker( void *pMaskFuncArg, int nBandCount, GDALDataType eType,
    00097                         int nXOff, int nYOff, int nXSize, int nYSize,
    00098                         GByte ** /*ppImageData */,
    00099                         int bMaskIsFloat, void *pValidityMask, int* pbOutAllOpaque );
    00100
    00101 CPLErr CPL_DLL
    00102 GDALWarpSrcMaskMasker( void *pMaskFuncArg, int nBandCount, GDALDataType eType,
    00103                        int nXOff, int nYOff, int nXSize, int nYSize,
    00104                        GByte ** /*ppImageData */,
    00105                        int bMaskIsFloat, void *pValidityMask );
    00106
    00107 CPLErr CPL_DLL
    00108 GDALWarpCutlineMasker( void *pMaskFuncArg, int nBandCount, GDALDataType eType,
    00109                        int nXOff, int nYOff, int nXSize, int nYSize,
    00110                        GByte ** /* ppImageData */,
    00111                        int bMaskIsFloat, void *pValidityMask );
    00112
    00113 /************************************************************************/
    00114 /*                           GDALWarpOptions                            */
    00115 /************************************************************************/
    00116
    00118 typedef struct {
    00119
    00120     char              **papszWarpOptions;
    00121
    00123     double              dfWarpMemoryLimit;
    00124
    00126     GDALResampleAlg     eResampleAlg;
    00127
    00130     GDALDataType        eWorkingDataType;
    00131
    00133     GDALDatasetH        hSrcDS;
    00134
    00136     GDALDatasetH        hDstDS;
    00137
    00139     int                 nBandCount;
    00140
    00142     int                *panSrcBands;
    00143
    00145     int                *panDstBands;
    00146
    00148     int                nSrcAlphaBand;
    00149
    00151     int                nDstAlphaBand;
    00152
    00154     double             *padfSrcNoDataReal;
    00157     double             *padfSrcNoDataImag;
    00158
    00160     double             *padfDstNoDataReal;
    00163     double             *padfDstNoDataImag;
    00164
    00167     GDALProgressFunc    pfnProgress;
    00168
    00170     void               *pProgressArg;
    00171
    00173     GDALTransformerFunc pfnTransformer;
    00174
    00176     void                *pTransformerArg;
    00177
    00178     GDALMaskFunc       *papfnSrcPerBandValidityMaskFunc;
    00179     void              **papSrcPerBandValidityMaskFuncArg;
    00180
    00181     GDALMaskFunc        pfnSrcValidityMaskFunc;
    00182     void               *pSrcValidityMaskFuncArg;
    00183
    00184     GDALMaskFunc        pfnSrcDensityMaskFunc;
    00185     void               *pSrcDensityMaskFuncArg;
    00186
    00187     GDALMaskFunc        pfnDstDensityMaskFunc;
    00188     void               *pDstDensityMaskFuncArg;
    00189
    00190     GDALMaskFunc        pfnDstValidityMaskFunc;
    00191     void               *pDstValidityMaskFuncArg;
    00192
    00193     CPLErr              (*pfnPreWarpChunkProcessor)( void *pKern, void *pArg );
    00194     void               *pPreWarpProcessorArg;
    00195
    00196     CPLErr              (*pfnPostWarpChunkProcessor)( void *pKern, void *pArg);
    00197     void               *pPostWarpProcessorArg;
    00198
    00200     void               *hCutline;
    00201
    00203     double              dfCutlineBlendDist;
    00204
    00205 } GDALWarpOptions;
    00206
    00207 GDALWarpOptions CPL_DLL * CPL_STDCALL GDALCreateWarpOptions(void);
    00208 void CPL_DLL CPL_STDCALL GDALDestroyWarpOptions( GDALWarpOptions * );
    00209 GDALWarpOptions CPL_DLL * CPL_STDCALL
    00210 GDALCloneWarpOptions( const GDALWarpOptions * );
    00211
    00212 CPLXMLNode CPL_DLL * CPL_STDCALL
    00213       GDALSerializeWarpOptions( const GDALWarpOptions * );
    00214 GDALWarpOptions CPL_DLL * CPL_STDCALL
    00215       GDALDeserializeWarpOptions( CPLXMLNode * );
    00216
    00217 /************************************************************************/
    00218 /*                         GDALReprojectImage()                         */
    00219 /************************************************************************/
    00220
    00221 CPLErr CPL_DLL CPL_STDCALL
    00222 GDALReprojectImage( GDALDatasetH hSrcDS, const char *pszSrcWKT,
    00223                     GDALDatasetH hDstDS, const char *pszDstWKT,
    00224                     GDALResampleAlg eResampleAlg, double dfWarpMemoryLimit,
    00225                     double dfMaxError,
    00226                     GDALProgressFunc pfnProgress, void *pProgressArg,
    00227                     GDALWarpOptions *psOptions );
    00228
    00229 CPLErr CPL_DLL CPL_STDCALL
    00230 GDALCreateAndReprojectImage( GDALDatasetH hSrcDS, const char *pszSrcWKT,
    00231                     const char *pszDstFilename, const char *pszDstWKT,
    00232                     GDALDriverH hDstDriver, char **papszCreateOptions,
    00233                     GDALResampleAlg eResampleAlg, double dfWarpMemoryLimit,
    00234                     double dfMaxError,
    00235                     GDALProgressFunc pfnProgress, void *pProgressArg,
    00236                     GDALWarpOptions *psOptions );
    00237
    00238 /************************************************************************/
    00239 /*                           VRTWarpedDataset                           */
    00240 /************************************************************************/
    00241
    00242 GDALDatasetH CPL_DLL CPL_STDCALL
    00243 GDALAutoCreateWarpedVRT( GDALDatasetH hSrcDS,
    00244                          const char *pszSrcWKT, const char *pszDstWKT,
    00245                          GDALResampleAlg eResampleAlg,
    00246                          double dfMaxError, const GDALWarpOptions *psOptions );
    00247
    00248 GDALDatasetH CPL_DLL CPL_STDCALL
    00249 GDALCreateWarpedVRT( GDALDatasetH hSrcDS,
    00250                      int nPixels, int nLines, double *padfGeoTransform,
    00251                      GDALWarpOptions *psOptions );
    00252
    00253 CPLErr CPL_DLL CPL_STDCALL
    00254 GDALInitializeWarpedVRT( GDALDatasetH hDS,
    00255                          GDALWarpOptions *psWO );
    00256
    00257 CPL_C_END
    00258
    00259 #ifdef __cplusplus
    00260
    00261 /************************************************************************/
    00262 /*                            GDALWarpKernel                            */
    00263 /*                                                                      */
    00264 /*      This class represents the lowest level of abstraction.  It      */
    00265 /*      is holds the imagery for one "chunk" of a warp, and the         */
    00266 /*      pre-prepared masks.  All IO is done before and after it's       */
    00267 /*      operation.  This class is not normally used by the              */
    00268 /*      application.                                                    */
    00269 /************************************************************************/
    00270
    00271 // This is the number of dummy pixels that must be reserved in source arrays
    00272 // in order to satisfy assumptions made in GWKResample(), and more specifically
    00273 // by GWKGetPixelRow() that always read a even number of pixels. So if we are
    00274 // in the situation to read the last pixel of the source array, we need 1 extra
    00275 // dummy pixel to avoid reading out of bounds.
    00276 #define WARP_EXTRA_ELTS    1
    00277
    00278 class CPL_DLL GDALWarpKernel
    00279 {
    00280 public:
    00281     char              **papszWarpOptions;
    00282
    00283     GDALResampleAlg     eResample;
    00284     GDALDataType        eWorkingDataType;
    00285     int                 nBands;
    00286
    00287     int                 nSrcXSize;
    00288     int                 nSrcYSize;
    00289     int                 nSrcXExtraSize; /* extra pixels (included in nSrcXSize) reserved for filter window. Should be ignored in scale computation */
    00290     int                 nSrcYExtraSize; /* extra pixels (included in nSrcYSize) reserved for filter window. Should be ignored in scale computation */
    00291     GByte               **papabySrcImage; /* each subarray must have WARP_EXTRA_ELTS at the end */
    00292
    00293     GUInt32           **papanBandSrcValid; /* each subarray must have WARP_EXTRA_ELTS at the end */
    00294     GUInt32            *panUnifiedSrcValid; /* must have WARP_EXTRA_ELTS at the end */
    00295     float              *pafUnifiedSrcDensity; /* must have WARP_EXTRA_ELTS at the end */
    00296
    00297     int                 nDstXSize;
    00298     int                 nDstYSize;
    00299     GByte             **papabyDstImage;
    00300     GUInt32            *panDstValid;
    00301     float              *pafDstDensity;
    00302
    00303     double              dfXScale;   // Resampling scale, i.e.
    00304     double              dfYScale;   // nDstSize/nSrcSize.
    00305     double              dfXFilter;  // Size of filter kernel.
    00306     double              dfYFilter;
    00307     int                 nXRadius;   // Size of window to filter.
    00308     int                 nYRadius;
    00309     int                 nFiltInitX; // Filtering offset
    00310     int                 nFiltInitY;
    00311
    00312     int                 nSrcXOff;
    00313     int                 nSrcYOff;
    00314
    00315     int                 nDstXOff;
    00316     int                 nDstYOff;
    00317
    00318     GDALTransformerFunc pfnTransformer;
    00319     void                *pTransformerArg;
    00320
    00321     GDALProgressFunc    pfnProgress;
    00322     void                *pProgress;
    00323
    00324     double              dfProgressBase;
    00325     double              dfProgressScale;
    00326
    00327     double              *padfDstNoDataReal;
    00328
    00329                        GDALWarpKernel();
    00330     virtual           ~GDALWarpKernel();
    00331
    00332     CPLErr              Validate();
    00333     CPLErr              PerformWarp();
    00334 };
    00335
    00336 /************************************************************************/
    00337 /*                         GDALWarpOperation()                          */
    00338 /*                                                                      */
    00339 /*      This object is application created, or created by a higher      */
    00340 /*      level convenience function.  It is responsible for              */
    00341 /*      subdividing the operation into chunks, loading and saving       */
    00342 /*      imagery, and establishing the varios validity and density       */
    00343 /*      masks.  Actual resampling is done by the GDALWarpKernel.        */
    00344 /************************************************************************/
    00345
    00346 typedef struct _GDALWarpChunk GDALWarpChunk;
    00347
    00348 class CPL_DLL GDALWarpOperation {
    00349 private:
    00350     GDALWarpOptions *psOptions;
    00351
    00352     void            WipeOptions();
    00353     int             ValidateOptions();
    00354
    00355     CPLErr          ComputeSourceWindow( int nDstXOff, int nDstYOff,
    00356                                          int nDstXSize, int nDstYSize,
    00357                                          int *pnSrcXOff, int *pnSrcYOff,
    00358                                          int *pnSrcXSize, int *pnSrcYSize,
    00359                                          int *pnSrcXExtraSize, int *pnSrcYExtraSize,
    00360                                          double* pdfSrcFillRatio );
    00361
    00362     CPLErr          CreateKernelMask( GDALWarpKernel *, int iBand,
    00363                                       const char *pszType );
    00364
    00365     CPLMutex        *hIOMutex;
    00366     CPLMutex        *hWarpMutex;
    00367
    00368     int             nChunkListCount;
    00369     int             nChunkListMax;
    00370     GDALWarpChunk  *pasChunkList;
    00371
    00372     int             bReportTimings;
    00373     unsigned long   nLastTimeReported;
    00374
    00375     void            WipeChunkList();
    00376     CPLErr          CollectChunkList( int nDstXOff, int nDstYOff,
    00377                                       int nDstXSize, int nDstYSize );
    00378     void            ReportTiming( const char * );
    00379
    00380 public:
    00381                     GDALWarpOperation();
    00382     virtual        ~GDALWarpOperation();
    00383
    00384     CPLErr          Initialize( const GDALWarpOptions *psNewOptions );
    00385
    00386     const GDALWarpOptions         *GetOptions();
    00387
    00388     CPLErr          ChunkAndWarpImage( int nDstXOff, int nDstYOff,
    00389                                        int nDstXSize, int nDstYSize );
    00390     CPLErr          ChunkAndWarpMulti( int nDstXOff, int nDstYOff,
    00391                                        int nDstXSize, int nDstYSize );
    00392     CPLErr          WarpRegion( int nDstXOff, int nDstYOff,
    00393                                 int nDstXSize, int nDstYSize,
    00394                                 int nSrcXOff=0, int nSrcYOff=0,
    00395                                 int nSrcXSize=0, int nSrcYSize=0,
    00396                                 double dfProgressBase=0.0, double dfProgressScale=1.0);
    00397     CPLErr          WarpRegion( int nDstXOff, int nDstYOff,
    00398                                 int nDstXSize, int nDstYSize,
    00399                                 int nSrcXOff, int nSrcYOff,
    00400                                 int nSrcXSize, int nSrcYSize,
    00401                                 int nSrcXExtraSize, int nSrcYExtraSize,
    00402                                 double dfProgressBase, double dfProgressScale);
    00403     CPLErr          WarpRegionToBuffer( int nDstXOff, int nDstYOff,
    00404                                         int nDstXSize, int nDstYSize,
    00405                                         void *pDataBuf,
    00406                                         GDALDataType eBufDataType,
    00407                                         int nSrcXOff=0, int nSrcYOff=0,
    00408                                         int nSrcXSize=0, int nSrcYSize=0,
    00409                                         double dfProgressBase=0.0, double dfProgressScale=1.0);
    00410     CPLErr          WarpRegionToBuffer( int nDstXOff, int nDstYOff,
    00411                                         int nDstXSize, int nDstYSize,
    00412                                         void *pDataBuf,
    00413                                         GDALDataType eBufDataType,
    00414                                         int nSrcXOff, int nSrcYOff,
    00415                                         int nSrcXSize, int nSrcYSize,
    00416                                         int nSrcXExtraSize, int nSrcYExtraSize,
    00417                                         double dfProgressBase, double dfProgressScale);
    00418 };
    00419
    00420 #endif /* def __cplusplus */
    00421
    00422 CPL_C_START
    00423
    00424 typedef void * GDALWarpOperationH;
    00425
    00426 GDALWarpOperationH CPL_DLL GDALCreateWarpOperation(const GDALWarpOptions* );
    00427 void CPL_DLL GDALDestroyWarpOperation( GDALWarpOperationH );
    00428 CPLErr CPL_DLL GDALChunkAndWarpImage( GDALWarpOperationH, int, int, int, int );
    00429 CPLErr CPL_DLL GDALChunkAndWarpMulti( GDALWarpOperationH, int, int, int, int );
    00430 CPLErr CPL_DLL GDALWarpRegion( GDALWarpOperationH,
    00431                                int, int, int, int, int, int, int, int );
    00432 CPLErr CPL_DLL GDALWarpRegionToBuffer( GDALWarpOperationH, int, int, int, int,
    00433                                        void *, GDALDataType,
    00434                                        int, int, int, int );
    00435
    00436 /************************************************************************/
    00437 /*      Warping kernel functions                                        */
    00438 /************************************************************************/
    00439
    00440 int GWKGetFilterRadius(GDALResampleAlg eResampleAlg);
    00441
    00442 typedef double (*FilterFuncType)(double dfX);
    00443 FilterFuncType GWKGetFilterFunc(GDALResampleAlg eResampleAlg);
    00444
    00445 typedef double (*FilterFunc4ValuesType)(double* padfVals);
    00446 FilterFunc4ValuesType GWKGetFilterFunc4Values(GDALResampleAlg eResampleAlg);
    00447
    00448 CPL_C_END
    00449
    00450 #endif /* ndef GDAL_ALG_H_INCLUDED */

Generated for GDAL by 1.7.1.