← Back to branch summary

~ubuntu-branches/debian/sid/gdal/sid

« back to all changes in this revision

Viewing changes to swig/include/Dataset.i

  • Committer: Package Import Robot
  • Author(s): Francesco Paolo Lovergine
  • Date: 2012-05-07 15:04:42 UTC
  • mfrom: (5.5.16 experimental)
  • Revision ID: package-import@ubuntu.com-20120507150442-2eks97loeh6rq005
Tags: 1.9.0-1
* Ready for sid, starting transition.
* All symfiles updated to latest builds.
* Added dh_numpy call in debian/rules to depend on numpy ABI.
* Policy bumped to 3.9.3, no changes required.

Show diffs side-by-side

added added

removed removed

Lines of Context:
swig/include/Dataset.i
1
1
/******************************************************************************
2
 
 * $Id: Dataset.i 17884 2009-10-23 21:34:11Z rouault $
 
2
 * $Id: Dataset.i 20641 2010-09-18 11:35:15Z rouault $
3
3
 *
4
4
 * Name:     Dataset.i
5
5
 * Project:  GDAL Python Interface
31
31
%{
32
32
/* Returned size is in bytes or 0 if an error occured */
33
33
static
34
 
int ComputeDatasetRasterIOSize (int buf_xsize, int buf_ysize, int nPixelSize,
 
34
GIntBig ComputeDatasetRasterIOSize (int buf_xsize, int buf_ysize, int nPixelSize,
35
35
                                int nBands, int* bandMap, int nBandMapArrayLength,
36
36
                                int nPixelSpace, int nLineSpace, int nBandSpace,
37
37
                                int bSpacingShouldBeMultipleOfPixelSize )
38
38
{
39
 
    const int MAX_INT = 0x7fffffff;
 
39
#if SIZEOF_VOIDP == 8
 
40
    const GIntBig MAX_INT = (((GIntBig)0x7fffffff) << 32) | 0xffffffff;
 
41
#else
 
42
    const GIntBig MAX_INT = 0x7fffffff;
 
43
#endif
 
44
    const GIntBig MAX_INT32 = 0x7fffffff;
40
45
    if (buf_xsize <= 0 || buf_ysize <= 0)
41
46
    {
42
47
        CPLError(CE_Failure, CPLE_IllegalArg, "Illegal values for buffer size");
65
70
 
66
71
    if( nLineSpace == 0 )
67
72
    {
68
 
        if (nPixelSpace > MAX_INT / buf_xsize)
 
73
        if (nPixelSpace > MAX_INT32 / buf_xsize)
69
74
        {
70
 
            CPLError(CE_Failure, CPLE_IllegalArg, "Integer overflow");
 
75
            CPLError(CE_Failure, CPLE_IllegalArg, "Integer overflow for nLineSpace");
71
76
            return 0;
72
77
        }
73
78
        nLineSpace = nPixelSpace * buf_xsize;
80
85
 
81
86
    if( nBandSpace == 0 )
82
87
    {
83
 
        if (nLineSpace > MAX_INT / buf_ysize)
 
88
        if (nLineSpace > MAX_INT32 / buf_ysize)
84
89
        {
85
 
            CPLError(CE_Failure, CPLE_IllegalArg, "Integer overflow");
 
90
            CPLError(CE_Failure, CPLE_IllegalArg, "Integer overflow for nBandSpace");
86
91
            return 0;
87
92
        }
88
93
        nBandSpace = nLineSpace * buf_ysize;
99
104
        return 0;
100
105
    }
101
106
 
102
 
    if ((buf_ysize - 1) > MAX_INT / nLineSpace ||
103
 
        (buf_xsize - 1) > MAX_INT / nPixelSpace ||
104
 
        (nBands - 1) > MAX_INT / nBandSpace ||
105
 
        (buf_ysize - 1) * nLineSpace > MAX_INT - (buf_xsize - 1) * nPixelSpace ||
106
 
        (buf_ysize - 1) * nLineSpace + (buf_xsize - 1) * nPixelSpace > MAX_INT - (nBands - 1) * nBandSpace ||
107
 
        (buf_ysize - 1) * nLineSpace + (buf_xsize - 1) * nPixelSpace + (nBands - 1) * nBandSpace > MAX_INT - nPixelSize)
 
107
    GIntBig nRet = (GIntBig)(buf_ysize - 1) * nLineSpace + (GIntBig)(buf_xsize - 1) * nPixelSpace + (GIntBig)(nBands - 1) * nBandSpace + nPixelSize;
 
108
    if (nRet > MAX_INT)
108
109
    {
109
110
        CPLError(CE_Failure, CPLE_IllegalArg, "Integer overflow");
110
111
        return 0;
111
112
    }
112
113
 
113
 
    return (buf_ysize - 1) * nLineSpace + (buf_xsize - 1) * nPixelSpace + (nBands - 1) * nBandSpace + nPixelSize;
 
114
    return nRet;
114
115
}
115
116
%}
116
117
 
117
 
#if !defined(SWIGCSHARP) && !defined(SWIGJAVA)
 
118
#if !defined(SWIGCSHARP) && !defined(SWIGJAVA) && !defined(SWIGPYTHON)
118
119
%{
119
120
static
120
121
CPLErr DSReadRaster_internal( GDALDatasetShadow *obj, 
126
127
                            int pixel_space, int line_space, int band_space)
127
128
{
128
129
  CPLErr result;
129
 
  
130
 
  *buf_size = ComputeDatasetRasterIOSize (buf_xsize, buf_ysize, GDALGetDataTypeSize( buf_type ) / 8,
 
130
 
 
131
  GIntBig nRequiredSize = ComputeDatasetRasterIOSize (buf_xsize, buf_ysize, GDALGetDataTypeSize( buf_type ) / 8,
131
132
                                          band_list ? band_list : GDALGetRasterCount(obj), pband_list, band_list,
132
133
                                          pixel_space, line_space, band_space, FALSE);
 
134
  if (nRequiredSize > 0x7fffffff)
 
135
  {
 
136
     CPLError(CE_Failure, CPLE_IllegalArg, "Integer overflow");
 
137
     nRequiredSize = 0;
 
138
  }
 
139
  *buf_size = (int)nRequiredSize;
133
140
  if (*buf_size == 0)
134
141
  {
135
142
      *buf = 0;
161
168
 
162
169
#endif
163
170
 
164
 
//************************************************************************
 
171
//************************************************************************/
 
172
//
 
173
// Define the extensions for GDALAsyncReader (nee GDALAsyncReaderShadow)
 
174
//
 
175
//************************************************************************/
 
176
%rename (AsyncReader) GDALAsyncReaderShadow;
 
177
 
 
178
 
 
179
%{
 
180
typedef struct
 
181
{
 
182
    GDALAsyncReaderH  hAsyncReader;
 
183
    void             *pyObject;
 
184
} GDALAsyncReaderWrapper;
 
185
 
 
186
typedef void* GDALAsyncReaderWrapperH;
 
187
 
 
188
static GDALAsyncReaderH AsyncReaderWrapperGetReader(GDALAsyncReaderWrapperH hWrapper)
 
189
{
 
190
    GDALAsyncReaderWrapper* psWrapper = (GDALAsyncReaderWrapper*)hWrapper;
 
191
    if (psWrapper->hAsyncReader == NULL)
 
192
    {
 
193
        CPLError(CE_Failure, CPLE_AppDefined, "AsyncReader object is defunct");
 
194
    }
 
195
    return psWrapper->hAsyncReader;
 
196
}
 
197
 
 
198
static void* AsyncReaderWrapperGetPyObject(GDALAsyncReaderWrapperH hWrapper)
 
199
{
 
200
    GDALAsyncReaderWrapper* psWrapper = (GDALAsyncReaderWrapper*)hWrapper;
 
201
    return psWrapper->pyObject;
 
202
}
 
203
 
 
204
static void DeleteAsyncReaderWrapper(GDALAsyncReaderWrapperH hWrapper)
 
205
{
 
206
    GDALAsyncReaderWrapper* psWrapper = (GDALAsyncReaderWrapper*)hWrapper;
 
207
    if (psWrapper->hAsyncReader != NULL)
 
208
    {
 
209
        CPLError(CE_Failure, CPLE_AppDefined,
 
210
                 "Native AsyncReader object will leak. EndAsyncReader() should have been called before");
 
211
    }
 
212
    CPLFree(psWrapper);
 
213
}
 
214
 
 
215
%}
 
216
 
 
217
#if defined(SWIGPYTHON)
 
218
%{
 
219
static GDALAsyncReaderWrapper* CreateAsyncReaderWrapper(GDALAsyncReaderH  hAsyncReader,
 
220
                                                        void             *pyObject)
 
221
{
 
222
    GDALAsyncReaderWrapper* psWrapper = (GDALAsyncReaderWrapper* )CPLMalloc(sizeof(GDALAsyncReaderWrapper));
 
223
    psWrapper->hAsyncReader = hAsyncReader;
 
224
    psWrapper->pyObject = pyObject;
 
225
    Py_INCREF((PyObject*) psWrapper->pyObject);
 
226
    return psWrapper;
 
227
}
 
228
 
 
229
static void DisableAsyncReaderWrapper(GDALAsyncReaderWrapperH hWrapper)
 
230
{
 
231
    GDALAsyncReaderWrapper* psWrapper = (GDALAsyncReaderWrapper*)hWrapper;
 
232
    if (psWrapper->pyObject)
 
233
    {
 
234
        Py_XDECREF((PyObject*) psWrapper->pyObject);
 
235
    }
 
236
    psWrapper->pyObject = NULL;
 
237
    psWrapper->hAsyncReader = NULL;
 
238
}
 
239
 
 
240
%}
 
241
#endif
 
242
 
 
243
class GDALAsyncReaderShadow {
 
244
private:
 
245
  GDALAsyncReaderShadow();
 
246
public:
 
247
%extend {
 
248
    ~GDALAsyncReaderShadow()
 
249
    {
 
250
        DeleteAsyncReaderWrapper(self);
 
251
    }
 
252
 
 
253
    %apply (int *OUTPUT) {(int *)};
 
254
    GDALAsyncStatusType GetNextUpdatedRegion(double timeout, int* xoff, int* yoff, int* buf_xsize, int* buf_ysize )
 
255
    {
 
256
        GDALAsyncReaderH hReader = AsyncReaderWrapperGetReader(self);
 
257
        if (hReader == NULL)
 
258
        {
 
259
            *xoff = 0;
 
260
            *yoff = 0;
 
261
            *buf_xsize = 0;
 
262
            *buf_ysize = 0;
 
263
            return GARIO_ERROR;
 
264
        }
 
265
        return GDALARGetNextUpdatedRegion(hReader, timeout, xoff, yoff, buf_xsize, buf_ysize );
 
266
    }
 
267
    %clear (int *);
 
268
 
 
269
#if defined(SWIGPYTHON)
 
270
    %apply ( void **outPythonObject ) { (void** ppRetPyObject ) };
 
271
    void GetBuffer(void** ppRetPyObject)
 
272
    {
 
273
        GDALAsyncReaderH hReader = AsyncReaderWrapperGetReader(self);
 
274
        if (hReader == NULL)
 
275
        {
 
276
            *ppRetPyObject = NULL;
 
277
            return;
 
278
        }
 
279
        *ppRetPyObject = AsyncReaderWrapperGetPyObject(self);
 
280
        Py_INCREF((PyObject*)*ppRetPyObject);
 
281
    }
 
282
    %clear (void** ppRetPyObject );
 
283
#endif
 
284
 
 
285
    int LockBuffer( double timeout )
 
286
    {
 
287
        GDALAsyncReaderH hReader = AsyncReaderWrapperGetReader(self);
 
288
        if (hReader == NULL)
 
289
        {
 
290
            return 0;
 
291
        }
 
292
        return GDALARLockBuffer(hReader,timeout);
 
293
    }
 
294
    
 
295
    void UnlockBuffer()
 
296
    {
 
297
        GDALAsyncReaderH hReader = AsyncReaderWrapperGetReader(self);
 
298
        if (hReader == NULL)
 
299
        {
 
300
            return;
 
301
        }
 
302
        GDALARUnlockBuffer(hReader);
 
303
    }
 
304
 
 
305
    } /* extend */
 
306
}; /* GDALAsyncReaderShadow */ 
 
307
 
 
308
//************************************************************************/
165
309
//
166
310
// Define the extensions for Dataset (nee GDALDatasetShadow)
167
311
//
168
 
//************************************************************************
 
312
//************************************************************************/
169
313
 
170
314
%rename (Dataset) GDALDatasetShadow;
171
315
 
206
350
    return GDALGetProjectionRef( self );
207
351
  }
208
352
 
 
353
  %apply Pointer NONNULL {char const *prj};
209
354
  CPLErr SetProjection( char const *prj ) {
210
355
    return GDALSetProjection( self, prj );
211
356
  }
 
357
  %clear char const *prj;
212
358
 
 
359
#ifdef SWIGPYTHON
 
360
%feature("kwargs") GetGeoTransform;
 
361
%apply (int *optional_int) { (int*) };
 
362
  void GetGeoTransform( double argout[6], int* isvalid, int* can_return_null = 0 ) {
 
363
    if (can_return_null && *can_return_null)
 
364
    {
 
365
        *isvalid = (GDALGetGeoTransform( self, argout ) == CE_None );
 
366
    }
 
367
    else
 
368
    {
 
369
        *isvalid = TRUE;
 
370
        if ( GDALGetGeoTransform( self, argout ) != CE_None ) {
 
371
            argout[0] = 0.0;
 
372
            argout[1] = 1.0;
 
373
            argout[2] = 0.0;
 
374
            argout[3] = 0.0;
 
375
            argout[4] = 0.0;
 
376
            argout[5] = 1.0;
 
377
        }
 
378
    }
 
379
  }
 
380
%clear (int*);
 
381
#else
213
382
  void GetGeoTransform( double argout[6] ) {
214
 
    if ( GDALGetGeoTransform( self, argout ) != 0 ) {
 
383
    if ( GDALGetGeoTransform( self, argout ) != CE_None ) {
215
384
      argout[0] = 0.0;
216
385
      argout[1] = 1.0;
217
386
      argout[2] = 0.0;
220
389
      argout[5] = 1.0;
221
390
    }
222
391
  }
 
392
#endif
223
393
 
224
394
  CPLErr SetGeoTransform( double argin[6] ) {
225
395
    return GDALSetGeoTransform( self, argin );
301
471
      return GDALCreateDatasetMaskBand( self, nFlags );
302
472
  }
303
473
 
304
 
#if defined(SWIGPYTHON) || defined (SWIGJAVA)
305
 
%apply (char **out_ppsz_and_free) {char **};
306
 
#else
307
 
/*  this is a required typemap (hi, Python and Java guys!) returned list is copied and CSLDestroy'ed */
308
474
%apply (char **CSL) {char **};
309
 
#endif
310
475
  char **GetFileList() {
311
476
    return GDALGetFileList( self );
312
477
  }
313
478
%clear char **;
314
479
 
315
 
#if !defined(SWIGCSHARP) && !defined(SWIGJAVA)
 
480
#if defined(SWIGPYTHON)
 
481
%feature("kwargs") WriteRaster;
 
482
%apply (GIntBig nLen, char *pBuf) { (GIntBig buf_len, char *buf_string) };
 
483
%apply (int *optional_int) { (int*) };
 
484
%apply (int *optional_int) { (GDALDataType *buf_type) };
 
485
%apply (int nList, int *pList ) { (int band_list, int *pband_list ) };
 
486
  CPLErr WriteRaster( int xoff, int yoff, int xsize, int ysize,
 
487
                      GIntBig buf_len, char *buf_string,
 
488
                      int *buf_xsize = 0, int *buf_ysize = 0,
 
489
                      GDALDataType *buf_type = 0,
 
490
                      int band_list = 0, int *pband_list = 0,
 
491
                      int* buf_pixel_space = 0, int* buf_line_space = 0, int* buf_band_space = 0) {
 
492
    CPLErr eErr;
 
493
    int nxsize = (buf_xsize==0) ? xsize : *buf_xsize;
 
494
    int nysize = (buf_ysize==0) ? ysize : *buf_ysize;
 
495
    GDALDataType ntype;
 
496
    if ( buf_type != 0 ) {
 
497
      ntype = (GDALDataType) *buf_type;
 
498
    } else {
 
499
      int lastband = GDALGetRasterCount( self ) - 1;
 
500
      if (lastband < 0)
 
501
        return CE_Failure;
 
502
      ntype = GDALGetRasterDataType( GDALGetRasterBand( self, lastband ) );
 
503
    }
 
504
 
 
505
    int pixel_space = (buf_pixel_space == 0) ? 0 : *buf_pixel_space;
 
506
    int line_space = (buf_line_space == 0) ? 0 : *buf_line_space;
 
507
    int band_space = (buf_band_space == 0) ? 0 : *buf_band_space;
 
508
 
 
509
    GIntBig min_buffer_size =
 
510
      ComputeDatasetRasterIOSize (nxsize, nysize, GDALGetDataTypeSize( ntype ) / 8,
 
511
                                  band_list ? band_list : GDALGetRasterCount(self), pband_list, band_list,
 
512
                                  pixel_space, line_space, band_space, FALSE);
 
513
    if (min_buffer_size == 0)
 
514
        return CE_Failure;
 
515
 
 
516
    if ( buf_len < min_buffer_size )
 
517
    {
 
518
        CPLError(CE_Failure, CPLE_AppDefined, "Buffer too small");
 
519
        return CE_Failure;
 
520
    }
 
521
 
 
522
    eErr = GDALDatasetRasterIO( self, GF_Write, xoff, yoff, xsize, ysize,
 
523
                                (void*) buf_string, nxsize, nysize, ntype,
 
524
                                band_list, pband_list, pixel_space, line_space, band_space );
 
525
 
 
526
    return eErr;
 
527
  }
 
528
%clear (int band_list, int *pband_list );
 
529
%clear (GDALDataType *buf_type);
 
530
%clear (int*);
 
531
%clear (GIntBig buf_len, char *buf_string);
 
532
#elif !defined(SWIGCSHARP) && !defined(SWIGJAVA)
316
533
%feature("kwargs") WriteRaster;
317
534
%apply (int nLen, char *pBuf) { (int buf_len, char *buf_string) };
318
535
%apply (int *optional_int) { (int*) };
319
536
%apply (int *optional_int) { (GDALDataType *buf_type) };
320
537
%apply (int nList, int *pList ) { (int band_list, int *pband_list ) };
321
538
  CPLErr WriteRaster( int xoff, int yoff, int xsize, int ysize,
322
 
                      int buf_len, char *buf_string,
 
539
                      int buf_len, char *buf_string,
323
540
                      int *buf_xsize = 0, int *buf_ysize = 0,
324
541
                      GDALDataType *buf_type = 0,
325
542
                      int band_list = 0, int *pband_list = 0,
341
558
    int line_space = (buf_line_space == 0) ? 0 : *buf_line_space;
342
559
    int band_space = (buf_band_space == 0) ? 0 : *buf_band_space;
343
560
 
344
 
    int min_buffer_size =
 
561
    GIntBig min_buffer_size =
345
562
      ComputeDatasetRasterIOSize (nxsize, nysize, GDALGetDataTypeSize( ntype ) / 8,
346
563
                                  band_list ? band_list : GDALGetRasterCount(self), pband_list, band_list,
347
564
                                  pixel_space, line_space, band_space, FALSE);
366
583
%clear (int buf_len, char *buf_string);
367
584
#endif
368
585
 
369
 
#if !defined(SWIGCSHARP) && !defined(SWIGJAVA)
 
586
#if !defined(SWIGCSHARP) && !defined(SWIGJAVA) && !defined(SWIGPYTHON)
370
587
%feature("kwargs") ReadRaster;
371
588
%apply (int *optional_int) { (GDALDataType *buf_type) };
372
589
%apply (int nList, int *pList ) { (int band_list, int *pband_list ) };
405
622
    return eErr;
406
623
}
407
624
  
 
625
%clear (GDALDataType *buf_type);
 
626
%clear (int band_list, int *pband_list );
408
627
%clear (int *buf_len, char **buf );
409
628
%clear (int*);
410
629
#endif
417
636
/* AdviseRead */
418
637
/* ReadRaster */
419
638
  
 
639
#if defined(SWIGPYTHON)
 
640
%feature("kwargs") BeginAsyncReader;
 
641
%newobject BeginAsyncReader;
 
642
%apply (int nList, int *pList ) { (int band_list, int *pband_list ) };
 
643
%apply (int nLenKeepObject, char *pBufKeepObject, void* pyObject) { (int buf_len, char *buf_string, void* pyObject) };
 
644
%apply (int *optional_int) { (int*) };  
 
645
  GDALAsyncReaderShadow* BeginAsyncReader(
 
646
       int xOff, int yOff, int xSize, int ySize,
 
647
       int buf_len, char *buf_string, void* pyObject,
 
648
       int buf_xsize, int buf_ysize, GDALDataType bufType = (GDALDataType)0,
 
649
       int band_list = 0, int *pband_list = 0, int nPixelSpace = 0,
 
650
       int nLineSpace = 0, int nBandSpace = 0, char **options = 0)  {
 
651
 
 
652
    if ((options != NULL) && (buf_xsize ==0) && (buf_ysize == 0))
 
653
    {
 
654
        // calculate an appropriate buffer size
 
655
        const char* pszLevel = CSLFetchNameValue(options, "LEVEL");
 
656
        if (pszLevel)
 
657
        {
 
658
            // round up
 
659
            int nLevel = atoi(pszLevel);
 
660
            int nRes = 2 << (nLevel - 1);
 
661
            buf_xsize = ceil(xSize / (1.0 * nRes));
 
662
            buf_ysize = ceil(ySize / (1.0 * nRes));
 
663
        }
 
664
    }
 
665
    
 
666
    int nxsize = (buf_xsize == 0) ? xSize : buf_xsize;
 
667
    int nysize = (buf_ysize == 0) ? ySize : buf_ysize;
 
668
    
 
669
    GDALDataType ntype;
 
670
    if (bufType != 0) {
 
671
        ntype = (GDALDataType) bufType;
 
672
    } 
 
673
    else {
 
674
        ntype = GDT_Byte;
 
675
    }
 
676
    
 
677
    int nBCount = (band_list) != 0 ? band_list : GDALGetRasterCount(self);
 
678
    int nMinSize = nxsize * nysize * nBCount * (GDALGetDataTypeSize(ntype) / 8);
 
679
    if (buf_string == NULL || buf_len < nMinSize)
 
680
    {
 
681
        CPLError(CE_Failure, CPLE_AppDefined, "Buffer is too small");
 
682
        return NULL;
 
683
    }
 
684
    
 
685
    bool myBandList = false;
 
686
    int* pBandList;
 
687
    
 
688
    if (band_list != 0){
 
689
        myBandList = false;
 
690
        pBandList = pband_list;
 
691
    }        
 
692
    else
 
693
    {
 
694
        myBandList = true;
 
695
        pBandList = (int*)CPLMalloc(sizeof(int) * nBCount);
 
696
        for (int i = 0; i < nBCount; ++i) {
 
697
            pBandList[i] = i + 1;
 
698
        }
 
699
    }
 
700
 
 
701
    GDALAsyncReaderH hAsyncReader =
 
702
            GDALBeginAsyncReader(self, xOff, yOff, xSize, ySize, (void*) buf_string, nxsize, nysize, ntype, nBCount, pBandList, nPixelSpace, nLineSpace,
 
703
    nBandSpace, options);
 
704
    if (hAsyncReader)
 
705
    {
 
706
        return (GDALAsyncReader*) CreateAsyncReaderWrapper(hAsyncReader, pyObject);
 
707
    }
 
708
    else
 
709
    {
 
710
        return NULL;
 
711
    }
 
712
    
 
713
    if ( myBandList ) {
 
714
       CPLFree( pBandList );
 
715
    }
 
716
 
 
717
  }
 
718
 
 
719
%clear(int band_list, int *pband_list);
 
720
%clear (int buf_len, char *buf_string, void* pyObject);
 
721
%clear(int*);
 
722
 
 
723
  void EndAsyncReader(GDALAsyncReaderShadow* ario){
 
724
    GDALAsyncReaderH hReader = AsyncReaderWrapperGetReader(ario);
 
725
    if (hReader == NULL)
 
726
    {
 
727
        return;
 
728
    }
 
729
    GDALEndAsyncReader(self, hReader);
 
730
    DisableAsyncReaderWrapper(ario);
 
731
  }
 
732
#endif
 
733
 
420
734
} /* extend */
421
735
}; /* GDALDatasetShadow */
422
736
 
431
745
  return GDALGetRasterCount( h );
432
746
}
433
747
%}
 
748