1
2
3
4
5
6
7 from sys import version_info as _swig_python_version_info
8 if _swig_python_version_info >= (2, 7, 0):
10 import importlib
11 pkg = __name__.rpartition('.')[0]
12 mname = '.'.join((pkg, '_gdal')).lstrip('.')
13 try:
14 return importlib.import_module(mname)
15 except ImportError:
16 return importlib.import_module('_gdal')
17 _gdal = swig_import_helper()
18 del swig_import_helper
19 elif _swig_python_version_info >= (2, 6, 0):
21 from os.path import dirname
22 import imp
23 fp = None
24 try:
25 fp, pathname, description = imp.find_module('_gdal', [dirname(__file__)])
26 except ImportError:
27 import _gdal
28 return _gdal
29 try:
30 _mod = imp.load_module('_gdal', fp, pathname, description)
31 finally:
32 if fp is not None:
33 fp.close()
34 return _mod
35 _gdal = swig_import_helper()
36 del swig_import_helper
37 else:
38 import _gdal
39 del _swig_python_version_info
40
41 try:
42 _swig_property = property
43 except NameError:
44 pass
45
46 try:
47 import builtins as __builtin__
48 except ImportError:
49 import __builtin__
50
52 if (name == "thisown"):
53 return self.this.own(value)
54 if (name == "this"):
55 if type(value).__name__ == 'SwigPyObject':
56 self.__dict__[name] = value
57 return
58 method = class_type.__swig_setmethods__.get(name, None)
59 if method:
60 return method(self, value)
61 if (not static):
62 if _newclass:
63 object.__setattr__(self, name, value)
64 else:
65 self.__dict__[name] = value
66 else:
67 raise AttributeError("You cannot add attributes to %s" % self)
68
69
72
73
75 if (name == "thisown"):
76 return self.this.own()
77 method = class_type.__swig_getmethods__.get(name, None)
78 if method:
79 return method(self)
80 raise AttributeError("'%s' object has no attribute '%s'" % (class_type.__name__, name))
81
82
84 try:
85 strthis = "proxy of " + self.this.__repr__()
86 except __builtin__.Exception:
87 strthis = ""
88 return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
89
90 try:
91 _object = object
92 _newclass = 1
93 except __builtin__.Exception:
96 _newclass = 0
97
98
99
100
101 have_warned = 0
103 global have_warned
104
105 if have_warned == 1:
106 return
107
108 have_warned = 1
109 if sub_package is None or sub_package == 'utils':
110 sub_package = 'osgeo_utils'
111 if new_module is None:
112 new_module = module
113 new_module = '{}.{}'.format(sub_package, new_module)
114
115 from warnings import warn
116 warn('{}.py was placed in a namespace, it is now available as {}' .format(module, new_module),
117 DeprecationWarning)
118
119
120 from osgeo.gdalconst import *
121 from osgeo import gdalconst
122
123
124 import sys
125 byteorders = {"little": "<",
126 "big": ">"}
127 array_modes = { gdalconst.GDT_Int16: ("%si2" % byteorders[sys.byteorder]),
128 gdalconst.GDT_UInt16: ("%su2" % byteorders[sys.byteorder]),
129 gdalconst.GDT_Int32: ("%si4" % byteorders[sys.byteorder]),
130 gdalconst.GDT_UInt32: ("%su4" % byteorders[sys.byteorder]),
131 gdalconst.GDT_Float32: ("%sf4" % byteorders[sys.byteorder]),
132 gdalconst.GDT_Float64: ("%sf8" % byteorders[sys.byteorder]),
133 gdalconst.GDT_CFloat32: ("%sf4" % byteorders[sys.byteorder]),
134 gdalconst.GDT_CFloat64: ("%sf8" % byteorders[sys.byteorder]),
135 gdalconst.GDT_Byte: ("%st8" % byteorders[sys.byteorder]),
136 }
137
139 src_ds = Open(src_filename)
140 if src_ds is None or src_ds == 'NULL':
141 return 1
142
143 ct = ColorTable()
144 err = ComputeMedianCutPCT(src_ds.GetRasterBand(1),
145 src_ds.GetRasterBand(2),
146 src_ds.GetRasterBand(3),
147 256, ct)
148 if err != 0:
149 return err
150
151 gtiff_driver = GetDriverByName('GTiff')
152 if gtiff_driver is None:
153 return 1
154
155 dst_ds = gtiff_driver.Create(dst_filename,
156 src_ds.RasterXSize, src_ds.RasterYSize)
157 dst_ds.GetRasterBand(1).SetRasterColorTable(ct)
158
159 err = DitherRGB2PCT(src_ds.GetRasterBand(1),
160 src_ds.GetRasterBand(2),
161 src_ds.GetRasterBand(3),
162 dst_ds.GetRasterBand(1),
163 ct)
164 dst_ds = None
165 src_ds = None
166
167 return 0
168
169 -def listdir(path, recursionLevel = -1, options = []):
170 """ Iterate over a directory.
171
172 recursionLevel = -1 means unlimited level of recursion.
173 """
174 dir = OpenDir(path, recursionLevel, options)
175 if not dir:
176 raise OSError(path + ' does not exist')
177 try:
178 while True:
179 entry = GetNextDirEntry(dir)
180 if not entry:
181 break
182 yield entry
183 finally:
184 CloseDir(dir)
185
186
190
194
198
200 """VSIFReadL(unsigned int nMembSize, unsigned int nMembCount, VSILFILE fp) -> unsigned int"""
201 return _gdal.VSIFReadL(*args)
202
206
207
208 -def InfoOptions(options=None, format='text', deserialize=True,
209 computeMinMax=False, reportHistograms=False, reportProj4=False,
210 stats=False, approxStats=False, computeChecksum=False,
211 showGCPs=True, showMetadata=True, showRAT=True, showColorTable=True,
212 listMDD=False, showFileList=True, allMetadata=False,
213 extraMDDomains=None, wktFormat=None):
214 """ Create a InfoOptions() object that can be passed to gdal.Info()
215 options can be be an array of strings, a string or let empty and filled from other keywords."""
216
217 options = [] if options is None else options
218
219 if isinstance(options, str):
220 new_options = ParseCommandLine(options)
221 format = 'text'
222 if '-json' in new_options:
223 format = 'json'
224 else:
225 new_options = options
226 if format == 'json':
227 new_options += ['-json']
228 if '-json' in new_options:
229 format = 'json'
230 if computeMinMax:
231 new_options += ['-mm']
232 if reportHistograms:
233 new_options += ['-hist']
234 if reportProj4:
235 new_options += ['-proj4']
236 if stats:
237 new_options += ['-stats']
238 if approxStats:
239 new_options += ['-approx_stats']
240 if computeChecksum:
241 new_options += ['-checksum']
242 if not showGCPs:
243 new_options += ['-nogcp']
244 if not showMetadata:
245 new_options += ['-nomd']
246 if not showRAT:
247 new_options += ['-norat']
248 if not showColorTable:
249 new_options += ['-noct']
250 if listMDD:
251 new_options += ['-listmdd']
252 if not showFileList:
253 new_options += ['-nofl']
254 if allMetadata:
255 new_options += ['-mdd', 'all']
256 if wktFormat:
257 new_options += ['-wkt_format', wktFormat]
258 if extraMDDomains is not None:
259 for mdd in extraMDDomains:
260 new_options += ['-mdd', mdd]
261
262 return (GDALInfoOptions(new_options), format, deserialize)
263
264 -def Info(ds, **kwargs):
265 """ Return information on a dataset.
266 Arguments are :
267 ds --- a Dataset object or a filename
268 Keyword arguments are :
269 options --- return of gdal.InfoOptions(), string or array of strings
270 other keywords arguments of gdal.InfoOptions()
271 If options is provided as a gdal.InfoOptions() object, other keywords are ignored. """
272 if 'options' not in kwargs or isinstance(kwargs['options'], (list, str)):
273 (opts, format, deserialize) = InfoOptions(**kwargs)
274 else:
275 (opts, format, deserialize) = kwargs['options']
276 if isinstance(ds, str):
277 ds = Open(ds)
278 ret = InfoInternal(ds, opts)
279 if format == 'json' and deserialize:
280 import json
281 ret = json.loads(ret)
282 return ret
283
284
285 -def MultiDimInfoOptions(options=None, detailed=False, array=None, arrayoptions=None, limit=None, as_text=False):
286 """ Create a MultiDimInfoOptions() object that can be passed to gdal.MultiDimInfo()
287 options can be be an array of strings, a string or let empty and filled from other keywords."""
288
289 options = [] if options is None else options
290
291 if isinstance(options, str):
292 new_options = ParseCommandLine(options)
293 else:
294 new_options = options
295 if detailed:
296 new_options += ['-detailed']
297 if array:
298 new_options += ['-array', array]
299 if limit:
300 new_options += ['-limit', str(limit)]
301 if arrayoptions:
302 for option in arrayoptions:
303 new_options += ['-arrayoption', option]
304
305 return GDALMultiDimInfoOptions(new_options), as_text
306
308 """ Return information on a dataset.
309 Arguments are :
310 ds --- a Dataset object or a filename
311 Keyword arguments are :
312 options --- return of gdal.MultiDimInfoOptions(), string or array of strings
313 other keywords arguments of gdal.MultiDimInfoOptions()
314 If options is provided as a gdal.MultiDimInfoOptions() object, other keywords are ignored. """
315 if 'options' not in kwargs or isinstance(kwargs['options'], (list, str)):
316 opts, as_text = MultiDimInfoOptions(**kwargs)
317 else:
318 opts = kwargs['options']
319 as_text = True
320 if isinstance(ds, str):
321 ds = OpenEx(ds, OF_VERBOSE_ERROR | OF_MULTIDIM_RASTER)
322 ret = MultiDimInfoInternal(ds, opts)
323 if not as_text:
324 import json
325 ret = json.loads(ret)
326 return ret
327
328
330 return ('%.18g' % x) if isinstance(x, float) else str(x)
331
332 mapGRIORAMethodToString = {
333 gdalconst.GRIORA_NearestNeighbour: 'near',
334 gdalconst.GRIORA_Bilinear: 'bilinear',
335 gdalconst.GRIORA_Cubic: 'cubic',
336 gdalconst.GRIORA_CubicSpline: 'cubicspline',
337 gdalconst.GRIORA_Lanczos: 'lanczos',
338 gdalconst.GRIORA_Average: 'average',
339 gdalconst.GRIORA_RMS: 'rms',
340 gdalconst.GRIORA_Mode: 'mode',
341 gdalconst.GRIORA_Gauss: 'gauss',
342 }
343
344 -def TranslateOptions(options=None, format=None,
345 outputType = gdalconst.GDT_Unknown, bandList=None, maskBand=None,
346 width = 0, height = 0, widthPct = 0.0, heightPct = 0.0,
347 xRes = 0.0, yRes = 0.0,
348 creationOptions=None, srcWin=None, projWin=None, projWinSRS=None, strict = False,
349 unscale = False, scaleParams=None, exponents=None,
350 outputBounds=None, metadataOptions=None,
351 outputSRS=None, nogcp=False, GCPs=None,
352 noData=None, rgbExpand=None,
353 stats = False, rat = True, xmp = True, resampleAlg=None,
354 callback=None, callback_data=None):
355 """ Create a TranslateOptions() object that can be passed to gdal.Translate()
356 Keyword arguments are :
357 options --- can be be an array of strings, a string or let empty and filled from other keywords.
358 format --- output format ("GTiff", etc...)
359 outputType --- output type (gdalconst.GDT_Byte, etc...)
360 bandList --- array of band numbers (index start at 1)
361 maskBand --- mask band to generate or not ("none", "auto", "mask", 1, ...)
362 width --- width of the output raster in pixel
363 height --- height of the output raster in pixel
364 widthPct --- width of the output raster in percentage (100 = original width)
365 heightPct --- height of the output raster in percentage (100 = original height)
366 xRes --- output horizontal resolution
367 yRes --- output vertical resolution
368 creationOptions --- list of creation options
369 srcWin --- subwindow in pixels to extract: [left_x, top_y, width, height]
370 projWin --- subwindow in projected coordinates to extract: [ulx, uly, lrx, lry]
371 projWinSRS --- SRS in which projWin is expressed
372 strict --- strict mode
373 unscale --- unscale values with scale and offset metadata
374 scaleParams --- list of scale parameters, each of the form [src_min,src_max] or [src_min,src_max,dst_min,dst_max]
375 exponents --- list of exponentiation parameters
376 outputBounds --- assigned output bounds: [ulx, uly, lrx, lry]
377 metadataOptions --- list of metadata options
378 outputSRS --- assigned output SRS
379 nogcp --- ignore GCP in the raster
380 GCPs --- list of GCPs
381 noData --- nodata value (or "none" to unset it)
382 rgbExpand --- Color palette expansion mode: "gray", "rgb", "rgba"
383 stats --- whether to calculate statistics
384 rat --- whether to write source RAT
385 xmp --- whether to copy XMP metadata
386 resampleAlg --- resampling mode
387 callback --- callback method
388 callback_data --- user data for callback
389 """
390
391
392 return_option_list = options == '__RETURN_OPTION_LIST__'
393 if return_option_list:
394 options = []
395 else:
396 options = [] if options is None else options
397
398 if isinstance(options, str):
399 new_options = ParseCommandLine(options)
400 else:
401 new_options = options
402 if format is not None:
403 new_options += ['-of', format]
404 if outputType != gdalconst.GDT_Unknown:
405 new_options += ['-ot', GetDataTypeName(outputType)]
406 if maskBand != None:
407 new_options += ['-mask', str(maskBand)]
408 if bandList != None:
409 for b in bandList:
410 new_options += ['-b', str(b)]
411 if width != 0 or height != 0:
412 new_options += ['-outsize', str(width), str(height)]
413 elif widthPct != 0 and heightPct != 0:
414 new_options += ['-outsize', str(widthPct) + '%%', str(heightPct) + '%%']
415 if creationOptions is not None:
416 if isinstance(creationOptions, str):
417 new_options += ['-co', creationOptions]
418 else:
419 for opt in creationOptions:
420 new_options += ['-co', opt]
421 if srcWin is not None:
422 new_options += ['-srcwin', _strHighPrec(srcWin[0]), _strHighPrec(srcWin[1]), _strHighPrec(srcWin[2]), _strHighPrec(srcWin[3])]
423 if strict:
424 new_options += ['-strict']
425 if unscale:
426 new_options += ['-unscale']
427 if scaleParams:
428 for scaleParam in scaleParams:
429 new_options += ['-scale']
430 for v in scaleParam:
431 new_options += [str(v)]
432 if exponents:
433 for exponent in exponents:
434 new_options += ['-exponent', _strHighPrec(exponent)]
435 if outputBounds is not None:
436 new_options += ['-a_ullr', _strHighPrec(outputBounds[0]), _strHighPrec(outputBounds[1]), _strHighPrec(outputBounds[2]), _strHighPrec(outputBounds[3])]
437 if metadataOptions is not None:
438 if isinstance(metadataOptions, str):
439 new_options += ['-mo', metadataOptions]
440 else:
441 for opt in metadataOptions:
442 new_options += ['-mo', opt]
443 if outputSRS is not None:
444 new_options += ['-a_srs', str(outputSRS)]
445 if nogcp:
446 new_options += ['-nogcp']
447 if GCPs is not None:
448 for gcp in GCPs:
449 new_options += ['-gcp', _strHighPrec(gcp.GCPPixel), _strHighPrec(gcp.GCPLine), _strHighPrec(gcp.GCPX), str(gcp.GCPY), _strHighPrec(gcp.GCPZ)]
450 if projWin is not None:
451 new_options += ['-projwin', _strHighPrec(projWin[0]), _strHighPrec(projWin[1]), _strHighPrec(projWin[2]), _strHighPrec(projWin[3])]
452 if projWinSRS is not None:
453 new_options += ['-projwin_srs', str(projWinSRS)]
454 if noData is not None:
455 new_options += ['-a_nodata', _strHighPrec(noData)]
456 if rgbExpand is not None:
457 new_options += ['-expand', str(rgbExpand)]
458 if stats:
459 new_options += ['-stats']
460 if not rat:
461 new_options += ['-norat']
462 if not xmp:
463 new_options += ['-noxmp']
464 if resampleAlg is not None:
465 if resampleAlg in mapGRIORAMethodToString:
466 new_options += ['-r', mapGRIORAMethodToString[resampleAlg]]
467 else:
468 new_options += ['-r', str(resampleAlg)]
469 if xRes != 0 and yRes != 0:
470 new_options += ['-tr', _strHighPrec(xRes), _strHighPrec(yRes)]
471
472 if return_option_list:
473 return new_options
474
475 return (GDALTranslateOptions(new_options), callback, callback_data)
476
478 """ Convert a dataset.
479 Arguments are :
480 destName --- Output dataset name
481 srcDS --- a Dataset object or a filename
482 Keyword arguments are :
483 options --- return of gdal.TranslateOptions(), string or array of strings
484 other keywords arguments of gdal.TranslateOptions()
485 If options is provided as a gdal.TranslateOptions() object, other keywords are ignored. """
486
487 if 'options' not in kwargs or isinstance(kwargs['options'], (list, str)):
488 (opts, callback, callback_data) = TranslateOptions(**kwargs)
489 else:
490 (opts, callback, callback_data) = kwargs['options']
491 if isinstance(srcDS, str):
492 srcDS = Open(srcDS)
493
494 return TranslateInternal(destName, srcDS, opts, callback, callback_data)
495
496 -def WarpOptions(options=None, format=None,
497 outputBounds=None,
498 outputBoundsSRS=None,
499 xRes=None, yRes=None, targetAlignedPixels = False,
500 width = 0, height = 0,
501 srcSRS=None, dstSRS=None,
502 coordinateOperation=None,
503 srcAlpha = False, dstAlpha = False,
504 warpOptions=None, errorThreshold=None,
505 warpMemoryLimit=None, creationOptions=None, outputType = gdalconst.GDT_Unknown,
506 workingType = gdalconst.GDT_Unknown, resampleAlg=None,
507 srcNodata=None, dstNodata=None, multithread = False,
508 tps = False, rpc = False, geoloc = False, polynomialOrder=None,
509 transformerOptions=None, cutlineDSName=None,
510 cutlineLayer=None, cutlineWhere=None, cutlineSQL=None, cutlineBlend=None, cropToCutline = False,
511 copyMetadata = True, metadataConflictValue=None,
512 setColorInterpretation = False,
513 overviewLevel = 'AUTO',
514 callback=None, callback_data=None):
515 """ Create a WarpOptions() object that can be passed to gdal.Warp()
516 Keyword arguments are :
517 options --- can be be an array of strings, a string or let empty and filled from other keywords.
518 format --- output format ("GTiff", etc...)
519 outputBounds --- output bounds as (minX, minY, maxX, maxY) in target SRS
520 outputBoundsSRS --- SRS in which output bounds are expressed, in the case they are not expressed in dstSRS
521 xRes, yRes --- output resolution in target SRS
522 targetAlignedPixels --- whether to force output bounds to be multiple of output resolution
523 width --- width of the output raster in pixel
524 height --- height of the output raster in pixel
525 srcSRS --- source SRS
526 dstSRS --- output SRS
527 coordinateOperation -- coordinate operation as a PROJ string or WKT string
528 srcAlpha --- whether to force the last band of the input dataset to be considered as an alpha band
529 dstAlpha --- whether to force the creation of an output alpha band
530 outputType --- output type (gdalconst.GDT_Byte, etc...)
531 workingType --- working type (gdalconst.GDT_Byte, etc...)
532 warpOptions --- list of warping options
533 errorThreshold --- error threshold for approximation transformer (in pixels)
534 warpMemoryLimit --- size of working buffer in MB
535 resampleAlg --- resampling mode
536 creationOptions --- list of creation options
537 srcNodata --- source nodata value(s)
538 dstNodata --- output nodata value(s)
539 multithread --- whether to multithread computation and I/O operations
540 tps --- whether to use Thin Plate Spline GCP transformer
541 rpc --- whether to use RPC transformer
542 geoloc --- whether to use GeoLocation array transformer
543 polynomialOrder --- order of polynomial GCP interpolation
544 transformerOptions --- list of transformer options
545 cutlineDSName --- cutline dataset name
546 cutlineLayer --- cutline layer name
547 cutlineWhere --- cutline WHERE clause
548 cutlineSQL --- cutline SQL statement
549 cutlineBlend --- cutline blend distance in pixels
550 cropToCutline --- whether to use cutline extent for output bounds
551 copyMetadata --- whether to copy source metadata
552 metadataConflictValue --- metadata data conflict value
553 setColorInterpretation --- whether to force color interpretation of input bands to output bands
554 overviewLevel --- To specify which overview level of source files must be used
555 callback --- callback method
556 callback_data --- user data for callback
557 """
558
559
560 return_option_list = options == '__RETURN_OPTION_LIST__'
561 if return_option_list:
562 options = []
563 else:
564 options = [] if options is None else options
565
566 if isinstance(options, str):
567 new_options = ParseCommandLine(options)
568 else:
569 new_options = options
570 if format is not None:
571 new_options += ['-of', format]
572 if outputType != gdalconst.GDT_Unknown:
573 new_options += ['-ot', GetDataTypeName(outputType)]
574 if workingType != gdalconst.GDT_Unknown:
575 new_options += ['-wt', GetDataTypeName(workingType)]
576 if outputBounds is not None:
577 new_options += ['-te', _strHighPrec(outputBounds[0]), _strHighPrec(outputBounds[1]), _strHighPrec(outputBounds[2]), _strHighPrec(outputBounds[3])]
578 if outputBoundsSRS is not None:
579 new_options += ['-te_srs', str(outputBoundsSRS)]
580 if xRes is not None and yRes is not None:
581 new_options += ['-tr', _strHighPrec(xRes), _strHighPrec(yRes)]
582 if width != 0 or height != 0:
583 new_options += ['-ts', str(width), str(height)]
584 if srcSRS is not None:
585 new_options += ['-s_srs', str(srcSRS)]
586 if dstSRS is not None:
587 new_options += ['-t_srs', str(dstSRS)]
588 if coordinateOperation is not None:
589 new_options += ['-ct', coordinateOperation]
590 if targetAlignedPixels:
591 new_options += ['-tap']
592 if srcAlpha:
593 new_options += ['-srcalpha']
594 if dstAlpha:
595 new_options += ['-dstalpha']
596 if warpOptions is not None:
597 for opt in warpOptions:
598 new_options += ['-wo', str(opt)]
599 if errorThreshold is not None:
600 new_options += ['-et', _strHighPrec(errorThreshold)]
601 if resampleAlg is not None:
602
603 mapMethodToString = {
604 gdalconst.GRA_NearestNeighbour: 'near',
605 gdalconst.GRA_Bilinear: 'bilinear',
606 gdalconst.GRA_Cubic: 'cubic',
607 gdalconst.GRA_CubicSpline: 'cubicspline',
608 gdalconst.GRA_Lanczos: 'lanczos',
609 gdalconst.GRA_Average: 'average',
610 gdalconst.GRA_RMS: 'rms',
611 gdalconst.GRA_Mode: 'mode',
612 gdalconst.GRA_Max: 'max',
613 gdalconst.GRA_Min: 'min',
614 gdalconst.GRA_Med: 'med',
615 gdalconst.GRA_Q1: 'q1',
616 gdalconst.GRA_Q3: 'q3',
617 gdalconst.GRA_Sum: 'sum',
618 }
619
620 if resampleAlg in mapMethodToString:
621 new_options += ['-r', mapMethodToString[resampleAlg]]
622 else:
623 new_options += ['-r', str(resampleAlg)]
624 if warpMemoryLimit is not None:
625 new_options += ['-wm', str(warpMemoryLimit)]
626 if creationOptions is not None:
627 for opt in creationOptions:
628 new_options += ['-co', opt]
629 if srcNodata is not None:
630 new_options += ['-srcnodata', str(srcNodata)]
631 if dstNodata is not None:
632 new_options += ['-dstnodata', str(dstNodata)]
633 if multithread:
634 new_options += ['-multi']
635 if tps:
636 new_options += ['-tps']
637 if rpc:
638 new_options += ['-rpc']
639 if geoloc:
640 new_options += ['-geoloc']
641 if polynomialOrder is not None:
642 new_options += ['-order', str(polynomialOrder)]
643 if transformerOptions is not None:
644 for opt in transformerOptions:
645 new_options += ['-to', opt]
646 if cutlineDSName is not None:
647 new_options += ['-cutline', str(cutlineDSName)]
648 if cutlineLayer is not None:
649 new_options += ['-cl', str(cutlineLayer)]
650 if cutlineWhere is not None:
651 new_options += ['-cwhere', str(cutlineWhere)]
652 if cutlineSQL is not None:
653 new_options += ['-csql', str(cutlineSQL)]
654 if cutlineBlend is not None:
655 new_options += ['-cblend', str(cutlineBlend)]
656 if cropToCutline:
657 new_options += ['-crop_to_cutline']
658 if not copyMetadata:
659 new_options += ['-nomd']
660 if metadataConflictValue:
661 new_options += ['-cvmd', str(metadataConflictValue)]
662 if setColorInterpretation:
663 new_options += ['-setci']
664
665 if overviewLevel is None or isinstance(overviewLevel, str):
666 pass
667 elif isinstance(overviewLevel, int):
668 if overviewLevel < 0:
669 overviewLevel = 'AUTO' + str(overviewLevel)
670 else:
671 overviewLevel = str(overviewLevel)
672 else:
673 overviewLevel = None
674
675 if overviewLevel is not None and overviewLevel != 'AUTO':
676 new_options += ['-ovr', overviewLevel]
677
678 if return_option_list:
679 return new_options
680
681 return (GDALWarpAppOptions(new_options), callback, callback_data)
682
683 -def Warp(destNameOrDestDS, srcDSOrSrcDSTab, **kwargs):
684 """ Warp one or several datasets.
685 Arguments are :
686 destNameOrDestDS --- Output dataset name or object
687 srcDSOrSrcDSTab --- an array of Dataset objects or filenames, or a Dataset object or a filename
688 Keyword arguments are :
689 options --- return of gdal.WarpOptions(), string or array of strings
690 other keywords arguments of gdal.WarpOptions()
691 If options is provided as a gdal.WarpOptions() object, other keywords are ignored. """
692
693 if 'options' not in kwargs or isinstance(kwargs['options'], (list, str)):
694 (opts, callback, callback_data) = WarpOptions(**kwargs)
695 else:
696 (opts, callback, callback_data) = kwargs['options']
697 if isinstance(srcDSOrSrcDSTab, str):
698 srcDSTab = [Open(srcDSOrSrcDSTab)]
699 elif isinstance(srcDSOrSrcDSTab, list):
700 srcDSTab = []
701 for elt in srcDSOrSrcDSTab:
702 if isinstance(elt, str):
703 srcDSTab.append(Open(elt))
704 else:
705 srcDSTab.append(elt)
706 else:
707 srcDSTab = [srcDSOrSrcDSTab]
708
709 if isinstance(destNameOrDestDS, str):
710 return wrapper_GDALWarpDestName(destNameOrDestDS, srcDSTab, opts, callback, callback_data)
711 else:
712 return wrapper_GDALWarpDestDS(destNameOrDestDS, srcDSTab, opts, callback, callback_data)
713
714
715 -def VectorTranslateOptions(options=None, format=None,
716 accessMode=None,
717 srcSRS=None, dstSRS=None, reproject=True,
718 coordinateOperation=None,
719 SQLStatement=None, SQLDialect=None, where=None, selectFields=None,
720 addFields=False,
721 forceNullable=False,
722 emptyStrAsNull=False,
723 spatFilter=None, spatSRS=None,
724 datasetCreationOptions=None,
725 layerCreationOptions=None,
726 layers=None,
727 layerName=None,
728 geometryType=None,
729 dim=None,
730 segmentizeMaxDist= None,
731 makeValid=False,
732 zField=None,
733 resolveDomains=False,
734 skipFailures=False,
735 limit=None,
736 callback=None, callback_data=None):
737 """ Create a VectorTranslateOptions() object that can be passed to gdal.VectorTranslate()
738 Keyword arguments are :
739 options --- can be be an array of strings, a string or let empty and filled from other keywords.
740 format --- output format ("ESRI Shapefile", etc...)
741 accessMode --- None for creation, 'update', 'append', 'overwrite'
742 srcSRS --- source SRS
743 dstSRS --- output SRS (with reprojection if reproject = True)
744 coordinateOperation -- coordinate operation as a PROJ string or WKT string
745 reproject --- whether to do reprojection
746 SQLStatement --- SQL statement to apply to the source dataset
747 SQLDialect --- SQL dialect ('OGRSQL', 'SQLITE', ...)
748 where --- WHERE clause to apply to source layer(s)
749 selectFields --- list of fields to select
750 addFields --- whether to add new fields found in source layers (to be used with accessMode == 'append')
751 forceNullable --- whether to drop NOT NULL constraints on newly created fields
752 emptyStrAsNull --- whether to treat empty string values as NULL
753 spatFilter --- spatial filter as (minX, minY, maxX, maxY) bounding box
754 spatSRS --- SRS in which the spatFilter is expressed. If not specified, it is assumed to be the one of the layer(s)
755 datasetCreationOptions --- list of dataset creation options
756 layerCreationOptions --- list of layer creation options
757 layers --- list of layers to convert
758 layerName --- output layer name
759 geometryType --- output layer geometry type ('POINT', ....)
760 dim --- output dimension ('XY', 'XYZ', 'XYM', 'XYZM', 'layer_dim')
761 segmentizeMaxDist --- maximum distance between consecutive nodes of a line geometry
762 makeValid --- run MakeValid() on geometries
763 zField --- name of field to use to set the Z component of geometries
764 resolveDomains --- whether to create an additional field for each field associated with a coded field domain.
765 skipFailures --- whether to skip failures
766 limit -- maximum number of features to read per layer
767 callback --- callback method
768 callback_data --- user data for callback
769 """
770 options = [] if options is None else options
771
772 if isinstance(options, str):
773 new_options = ParseCommandLine(options)
774 else:
775 new_options = options
776 if format is not None:
777 new_options += ['-f', format]
778 if srcSRS is not None:
779 new_options += ['-s_srs', str(srcSRS)]
780 if dstSRS is not None:
781 if reproject:
782 new_options += ['-t_srs', str(dstSRS)]
783 else:
784 new_options += ['-a_srs', str(dstSRS)]
785 if coordinateOperation is not None:
786 new_options += ['-ct', coordinateOperation]
787 if SQLStatement is not None:
788 new_options += ['-sql', str(SQLStatement)]
789 if SQLDialect is not None:
790 new_options += ['-dialect', str(SQLDialect)]
791 if where is not None:
792 new_options += ['-where', str(where)]
793 if accessMode is not None:
794 if accessMode == 'update':
795 new_options += ['-update']
796 elif accessMode == 'append':
797 new_options += ['-append']
798 elif accessMode == 'overwrite':
799 new_options += ['-overwrite']
800 else:
801 raise Exception('unhandled accessMode')
802 if addFields:
803 new_options += ['-addfields']
804 if forceNullable:
805 new_options += ['-forceNullable']
806 if emptyStrAsNull:
807 new_options += ['-emptyStrAsNull']
808 if selectFields is not None:
809 val = ''
810 for item in selectFields:
811 if val:
812 val += ','
813 val += item
814 new_options += ['-select', val]
815 if datasetCreationOptions is not None:
816 for opt in datasetCreationOptions:
817 new_options += ['-dsco', opt]
818 if layerCreationOptions is not None:
819 for opt in layerCreationOptions:
820 new_options += ['-lco', opt]
821 if layers is not None:
822 if isinstance(layers, str):
823 new_options += [layers]
824 else:
825 for lyr in layers:
826 new_options += [lyr]
827 if segmentizeMaxDist is not None:
828 new_options += ['-segmentize', str(segmentizeMaxDist)]
829 if makeValid:
830 new_options += ['-makevalid']
831 if spatFilter is not None:
832 new_options += ['-spat', str(spatFilter[0]), str(spatFilter[1]), str(spatFilter[2]), str(spatFilter[3])]
833 if spatSRS is not None:
834 new_options += ['-spat_srs', str(spatSRS)]
835 if layerName is not None:
836 new_options += ['-nln', layerName]
837 if geometryType is not None:
838 if isinstance(geometryType, str):
839 new_options += ['-nlt', geometryType]
840 else:
841 for opt in geometryType:
842 new_options += ['-nlt', opt]
843 if dim is not None:
844 new_options += ['-dim', dim]
845 if zField is not None:
846 new_options += ['-zfield', zField]
847 if resolveDomains:
848 new_options += ['-resolveDomains']
849 if skipFailures:
850 new_options += ['-skip']
851 if limit is not None:
852 new_options += ['-limit', str(limit)]
853 if callback is not None:
854 new_options += ['-progress']
855
856 return (GDALVectorTranslateOptions(new_options), callback, callback_data)
857
859 """ Convert one vector dataset
860 Arguments are :
861 destNameOrDestDS --- Output dataset name or object
862 srcDS --- a Dataset object or a filename
863 Keyword arguments are :
864 options --- return of gdal.VectorTranslateOptions(), string or array of strings
865 other keywords arguments of gdal.VectorTranslateOptions()
866 If options is provided as a gdal.VectorTranslateOptions() object, other keywords are ignored. """
867
868 if 'options' not in kwargs or isinstance(kwargs['options'], (list, str)):
869 (opts, callback, callback_data) = VectorTranslateOptions(**kwargs)
870 else:
871 (opts, callback, callback_data) = kwargs['options']
872 if isinstance(srcDS, str):
873 srcDS = OpenEx(srcDS, gdalconst.OF_VECTOR)
874
875 if isinstance(destNameOrDestDS, str):
876 return wrapper_GDALVectorTranslateDestName(destNameOrDestDS, srcDS, opts, callback, callback_data)
877 else:
878 return wrapper_GDALVectorTranslateDestDS(destNameOrDestDS, srcDS, opts, callback, callback_data)
879
880 -def DEMProcessingOptions(options=None, colorFilename=None, format=None,
881 creationOptions=None, computeEdges=False, alg=None, band=1,
882 zFactor=None, scale=None, azimuth=None, altitude=None,
883 combined=False, multiDirectional=False, igor=False,
884 slopeFormat=None, trigonometric=False, zeroForFlat=False,
885 addAlpha=None, colorSelection=None,
886 callback=None, callback_data=None):
887 """ Create a DEMProcessingOptions() object that can be passed to gdal.DEMProcessing()
888 Keyword arguments are :
889 options --- can be be an array of strings, a string or let empty and filled from other keywords.
890 colorFilename --- (mandatory for "color-relief") name of file that contains palette definition for the "color-relief" processing.
891 format --- output format ("GTiff", etc...)
892 creationOptions --- list of creation options
893 computeEdges --- whether to compute values at raster edges.
894 alg --- 'Horn' (default) or 'ZevenbergenThorne' for hillshade, slope or aspect. 'Wilson' (default) or 'Riley' for TRI
895 band --- source band number to use
896 zFactor --- (hillshade only) vertical exaggeration used to pre-multiply the elevations.
897 scale --- ratio of vertical units to horizontal.
898 azimuth --- (hillshade only) azimuth of the light, in degrees. 0 if it comes from the top of the raster, 90 from the east, ... The default value, 315, should rarely be changed as it is the value generally used to generate shaded maps.
899 altitude ---(hillshade only) altitude of the light, in degrees. 90 if the light comes from above the DEM, 0 if it is raking light.
900 combined --- (hillshade only) whether to compute combined shading, a combination of slope and oblique shading. Only one of combined, multiDirectional and igor can be specified.
901 multiDirectional --- (hillshade only) whether to compute multi-directional shading. Only one of combined, multiDirectional and igor can be specified.
902 igor --- (hillshade only) whether to use Igor's hillshading from Maperitive. Only one of combined, multiDirectional and igor can be specified.
903 slopeformat --- (slope only) "degree" or "percent".
904 trigonometric --- (aspect only) whether to return trigonometric angle instead of azimuth. Thus 0deg means East, 90deg North, 180deg West, 270deg South.
905 zeroForFlat --- (aspect only) whether to return 0 for flat areas with slope=0, instead of -9999.
906 addAlpha --- adds an alpha band to the output file (only for processing = 'color-relief')
907 colorSelection --- (color-relief only) Determines how color entries are selected from an input value. Can be "nearest_color_entry", "exact_color_entry" or "linear_interpolation". Defaults to "linear_interpolation"
908 callback --- callback method
909 callback_data --- user data for callback
910 """
911 options = [] if options is None else options
912
913 if isinstance(options, str):
914 new_options = ParseCommandLine(options)
915 else:
916 new_options = options
917 if format is not None:
918 new_options += ['-of', format]
919 if creationOptions is not None:
920 for opt in creationOptions:
921 new_options += ['-co', opt]
922 if computeEdges:
923 new_options += ['-compute_edges']
924 if alg:
925 new_options += ['-alg', alg]
926 new_options += ['-b', str(band)]
927 if zFactor is not None:
928 new_options += ['-z', str(zFactor)]
929 if scale is not None:
930 new_options += ['-s', str(scale)]
931 if azimuth is not None:
932 new_options += ['-az', str(azimuth)]
933 if altitude is not None:
934 new_options += ['-alt', str(altitude)]
935 if combined:
936 new_options += ['-combined']
937 if multiDirectional:
938 new_options += ['-multidirectional']
939 if igor:
940 new_options += ['-igor']
941 if slopeFormat == 'percent':
942 new_options += ['-p']
943 if trigonometric:
944 new_options += ['-trigonometric']
945 if zeroForFlat:
946 new_options += ['-zero_for_flat']
947 if colorSelection is not None:
948 if colorSelection == 'nearest_color_entry':
949 new_options += ['-nearest_color_entry']
950 elif colorSelection == 'exact_color_entry':
951 new_options += ['-exact_color_entry']
952 elif colorSelection == 'linear_interpolation':
953 pass
954 else:
955 raise ValueError("Unsupported value for colorSelection")
956 if addAlpha:
957 new_options += ['-alpha']
958
959 return (GDALDEMProcessingOptions(new_options), colorFilename, callback, callback_data)
960
962 """ Apply a DEM processing.
963 Arguments are :
964 destName --- Output dataset name
965 srcDS --- a Dataset object or a filename
966 processing --- one of "hillshade", "slope", "aspect", "color-relief", "TRI", "TPI", "Roughness"
967 Keyword arguments are :
968 options --- return of gdal.DEMProcessingOptions(), string or array of strings
969 other keywords arguments of gdal.DEMProcessingOptions()
970 If options is provided as a gdal.DEMProcessingOptions() object, other keywords are ignored. """
971
972 if 'options' not in kwargs or isinstance(kwargs['options'], (list, str)):
973 (opts, colorFilename, callback, callback_data) = DEMProcessingOptions(**kwargs)
974 else:
975 (opts, colorFilename, callback, callback_data) = kwargs['options']
976 if isinstance(srcDS, str):
977 srcDS = Open(srcDS)
978
979 return DEMProcessingInternal(destName, srcDS, processing, colorFilename, opts, callback, callback_data)
980
981
982 -def NearblackOptions(options=None, format=None,
983 creationOptions=None, white = False, colors=None,
984 maxNonBlack=None, nearDist=None, setAlpha = False, setMask = False,
985 callback=None, callback_data=None):
986 """ Create a NearblackOptions() object that can be passed to gdal.Nearblack()
987 Keyword arguments are :
988 options --- can be be an array of strings, a string or let empty and filled from other keywords.
989 format --- output format ("GTiff", etc...)
990 creationOptions --- list of creation options
991 white --- whether to search for nearly white (255) pixels instead of nearly black pixels.
992 colors --- list of colors to search for, e.g. ((0,0,0),(255,255,255)). The pixels that are considered as the collar are set to 0
993 maxNonBlack --- number of non-black (or other searched colors specified with white / colors) pixels that can be encountered before the giving up search inwards. Defaults to 2.
994 nearDist --- select how far from black, white or custom colors the pixel values can be and still considered near black, white or custom color. Defaults to 15.
995 setAlpha --- adds an alpha band to the output file.
996 setMask --- adds a mask band to the output file.
997 callback --- callback method
998 callback_data --- user data for callback
999 """
1000 options = [] if options is None else options
1001
1002 if isinstance(options, str):
1003 new_options = ParseCommandLine(options)
1004 else:
1005 new_options = options
1006 if format is not None:
1007 new_options += ['-of', format]
1008 if creationOptions is not None:
1009 for opt in creationOptions:
1010 new_options += ['-co', opt]
1011 if white:
1012 new_options += ['-white']
1013 if colors is not None:
1014 for color in colors:
1015 color_str = ''
1016 for cpt in color:
1017 if color_str != '':
1018 color_str += ','
1019 color_str += str(cpt)
1020 new_options += ['-color', color_str]
1021 if maxNonBlack is not None:
1022 new_options += ['-nb', str(maxNonBlack)]
1023 if nearDist is not None:
1024 new_options += ['-near', str(nearDist)]
1025 if setAlpha:
1026 new_options += ['-setalpha']
1027 if setMask:
1028 new_options += ['-setmask']
1029
1030 return (GDALNearblackOptions(new_options), callback, callback_data)
1031
1032 -def Nearblack(destNameOrDestDS, srcDS, **kwargs):
1033 """ Convert nearly black/white borders to exact value.
1034 Arguments are :
1035 destNameOrDestDS --- Output dataset name or object
1036 srcDS --- a Dataset object or a filename
1037 Keyword arguments are :
1038 options --- return of gdal.NearblackOptions(), string or array of strings
1039 other keywords arguments of gdal.NearblackOptions()
1040 If options is provided as a gdal.NearblackOptions() object, other keywords are ignored. """
1041
1042 if 'options' not in kwargs or isinstance(kwargs['options'], (list, str)):
1043 (opts, callback, callback_data) = NearblackOptions(**kwargs)
1044 else:
1045 (opts, callback, callback_data) = kwargs['options']
1046 if isinstance(srcDS, str):
1047 srcDS = OpenEx(srcDS)
1048
1049 if isinstance(destNameOrDestDS, str):
1050 return wrapper_GDALNearblackDestName(destNameOrDestDS, srcDS, opts, callback, callback_data)
1051 else:
1052 return wrapper_GDALNearblackDestDS(destNameOrDestDS, srcDS, opts, callback, callback_data)
1053
1054
1055 -def GridOptions(options=None, format=None,
1056 outputType=gdalconst.GDT_Unknown,
1057 width=0, height=0,
1058 creationOptions=None,
1059 outputBounds=None,
1060 outputSRS=None,
1061 noData=None,
1062 algorithm=None,
1063 layers=None,
1064 SQLStatement=None,
1065 where=None,
1066 spatFilter=None,
1067 zfield=None,
1068 z_increase=None,
1069 z_multiply=None,
1070 callback=None, callback_data=None):
1071 """ Create a GridOptions() object that can be passed to gdal.Grid()
1072 Keyword arguments are :
1073 options --- can be be an array of strings, a string or let empty and filled from other keywords.
1074 format --- output format ("GTiff", etc...)
1075 outputType --- output type (gdalconst.GDT_Byte, etc...)
1076 width --- width of the output raster in pixel
1077 height --- height of the output raster in pixel
1078 creationOptions --- list of creation options
1079 outputBounds --- assigned output bounds: [ulx, uly, lrx, lry]
1080 outputSRS --- assigned output SRS
1081 noData --- nodata value
1082 algorithm --- e.g "invdist:power=2.0:smoothing=0.0:radius1=0.0:radius2=0.0:angle=0.0:max_points=0:min_points=0:nodata=0.0"
1083 layers --- list of layers to convert
1084 SQLStatement --- SQL statement to apply to the source dataset
1085 where --- WHERE clause to apply to source layer(s)
1086 spatFilter --- spatial filter as (minX, minY, maxX, maxY) bounding box
1087 zfield --- Identifies an attribute field on the features to be used to get a Z value from. This value overrides Z value read from feature geometry record.
1088 z_increase --- Addition to the attribute field on the features to be used to get a Z value from. The addition should be the same unit as Z value. The result value will be Z value + Z increase value. The default value is 0.
1089 z_multiply - Multiplication ratio for Z field. This can be used for shift from e.g. foot to meters or from elevation to deep. The result value will be (Z value + Z increase value) * Z multiply value. The default value is 1.
1090 callback --- callback method
1091 callback_data --- user data for callback
1092 """
1093 options = [] if options is None else options
1094
1095 if isinstance(options, str):
1096 new_options = ParseCommandLine(options)
1097 else:
1098 new_options = options
1099 if format is not None:
1100 new_options += ['-of', format]
1101 if outputType != gdalconst.GDT_Unknown:
1102 new_options += ['-ot', GetDataTypeName(outputType)]
1103 if width != 0 or height != 0:
1104 new_options += ['-outsize', str(width), str(height)]
1105 if creationOptions is not None:
1106 for opt in creationOptions:
1107 new_options += ['-co', opt]
1108 if outputBounds is not None:
1109 new_options += ['-txe', _strHighPrec(outputBounds[0]), _strHighPrec(outputBounds[2]), '-tye', _strHighPrec(outputBounds[1]), _strHighPrec(outputBounds[3])]
1110 if outputSRS is not None:
1111 new_options += ['-a_srs', str(outputSRS)]
1112 if algorithm is not None:
1113 new_options += ['-a', algorithm]
1114 if layers is not None:
1115 if isinstance(layers, (tuple, list)):
1116 for layer in layers:
1117 new_options += ['-l', layer]
1118 else:
1119 new_options += ['-l', layers]
1120 if SQLStatement is not None:
1121 new_options += ['-sql', str(SQLStatement)]
1122 if where is not None:
1123 new_options += ['-where', str(where)]
1124 if zfield is not None:
1125 new_options += ['-zfield', zfield]
1126 if z_increase is not None:
1127 new_options += ['-z_increase', str(z_increase)]
1128 if z_multiply is not None:
1129 new_options += ['-z_multiply', str(z_multiply)]
1130 if spatFilter is not None:
1131 new_options += ['-spat', str(spatFilter[0]), str(spatFilter[1]), str(spatFilter[2]), str(spatFilter[3])]
1132
1133 return (GDALGridOptions(new_options), callback, callback_data)
1134
1135 -def Grid(destName, srcDS, **kwargs):
1136 """ Create raster from the scattered data.
1137 Arguments are :
1138 destName --- Output dataset name
1139 srcDS --- a Dataset object or a filename
1140 Keyword arguments are :
1141 options --- return of gdal.GridOptions(), string or array of strings
1142 other keywords arguments of gdal.GridOptions()
1143 If options is provided as a gdal.GridOptions() object, other keywords are ignored. """
1144
1145 if 'options' not in kwargs or isinstance(kwargs['options'], (list, str)):
1146 (opts, callback, callback_data) = GridOptions(**kwargs)
1147 else:
1148 (opts, callback, callback_data) = kwargs['options']
1149 if isinstance(srcDS, str):
1150 srcDS = OpenEx(srcDS, gdalconst.OF_VECTOR)
1151
1152 return GridInternal(destName, srcDS, opts, callback, callback_data)
1153
1154 -def RasterizeOptions(options=None, format=None,
1155 outputType=gdalconst.GDT_Unknown,
1156 creationOptions=None, noData=None, initValues=None,
1157 outputBounds=None, outputSRS=None,
1158 transformerOptions=None,
1159 width=None, height=None,
1160 xRes=None, yRes=None, targetAlignedPixels=False,
1161 bands=None, inverse=False, allTouched=False,
1162 burnValues=None, attribute=None, useZ=False, layers=None,
1163 SQLStatement=None, SQLDialect=None, where=None, optim=None,
1164 add=None,
1165 callback=None, callback_data=None):
1166 """ Create a RasterizeOptions() object that can be passed to gdal.Rasterize()
1167 Keyword arguments are :
1168 options --- can be be an array of strings, a string or let empty and filled from other keywords.
1169 format --- output format ("GTiff", etc...)
1170 outputType --- output type (gdalconst.GDT_Byte, etc...)
1171 creationOptions --- list of creation options
1172 outputBounds --- assigned output bounds: [minx, miny, maxx, maxy]
1173 outputSRS --- assigned output SRS
1174 transformerOptions --- list of transformer options
1175 width --- width of the output raster in pixel
1176 height --- height of the output raster in pixel
1177 xRes, yRes --- output resolution in target SRS
1178 targetAlignedPixels --- whether to force output bounds to be multiple of output resolution
1179 noData --- nodata value
1180 initValues --- Value or list of values to pre-initialize the output image bands with. However, it is not marked as the nodata value in the output file. If only one value is given, the same value is used in all the bands.
1181 bands --- list of output bands to burn values into
1182 inverse --- whether to invert rasterization, i.e. burn the fixed burn value, or the burn value associated with the first feature into all parts of the image not inside the provided a polygon.
1183 allTouched -- whether to enable the ALL_TOUCHED rasterization option so that all pixels touched by lines or polygons will be updated, not just those on the line render path, or whose center point is within the polygon.
1184 burnValues -- list of fixed values to burn into each band for all objects. Excusive with attribute.
1185 attribute --- identifies an attribute field on the features to be used for a burn-in value. The value will be burned into all output bands. Excusive with burnValues.
1186 useZ --- whether to indicate that a burn value should be extracted from the "Z" values of the feature. These values are added to the burn value given by burnValues or attribute if provided. As of now, only points and lines are drawn in 3D.
1187 layers --- list of layers from the datasource that will be used for input features.
1188 SQLStatement --- SQL statement to apply to the source dataset
1189 SQLDialect --- SQL dialect ('OGRSQL', 'SQLITE', ...)
1190 where --- WHERE clause to apply to source layer(s)
1191 optim --- optimization mode ('RASTER', 'VECTOR')
1192 add --- set to True to use additive mode instead of replace when burning values
1193 callback --- callback method
1194 callback_data --- user data for callback
1195 """
1196 options = [] if options is None else options
1197
1198 if isinstance(options, str):
1199 new_options = ParseCommandLine(options)
1200 else:
1201 new_options = options
1202 if format is not None:
1203 new_options += ['-of', format]
1204 if outputType != gdalconst.GDT_Unknown:
1205 new_options += ['-ot', GetDataTypeName(outputType)]
1206 if creationOptions is not None:
1207 for opt in creationOptions:
1208 new_options += ['-co', opt]
1209 if bands is not None:
1210 for b in bands:
1211 new_options += ['-b', str(b)]
1212 if noData is not None:
1213 new_options += ['-a_nodata', str(noData)]
1214 if initValues is not None:
1215 if isinstance(initValues, (tuple, list)):
1216 for val in initValues:
1217 new_options += ['-init', str(val)]
1218 else:
1219 new_options += ['-init', str(initValues)]
1220 if outputBounds is not None:
1221 new_options += ['-te', _strHighPrec(outputBounds[0]), _strHighPrec(outputBounds[1]), _strHighPrec(outputBounds[2]), _strHighPrec(outputBounds[3])]
1222 if outputSRS is not None:
1223 new_options += ['-a_srs', str(outputSRS)]
1224 if transformerOptions is not None:
1225 for opt in transformerOptions:
1226 new_options += ['-to', opt]
1227 if width is not None and height is not None:
1228 new_options += ['-ts', str(width), str(height)]
1229 if xRes is not None and yRes is not None:
1230 new_options += ['-tr', _strHighPrec(xRes), _strHighPrec(yRes)]
1231 if targetAlignedPixels:
1232 new_options += ['-tap']
1233 if inverse:
1234 new_options += ['-i']
1235 if allTouched:
1236 new_options += ['-at']
1237 if burnValues is not None:
1238 if attribute is not None:
1239 raise Exception('burnValues and attribute option are exclusive.')
1240 if isinstance(burnValues, (tuple, list)):
1241 for val in burnValues:
1242 new_options += ['-burn', str(val)]
1243 else:
1244 new_options += ['-burn', str(burnValues)]
1245 if attribute is not None:
1246 new_options += ['-a', attribute]
1247 if useZ:
1248 new_options += ['-3d']
1249 if layers is not None:
1250 if isinstance(layers, ((tuple, list))):
1251 for layer in layers:
1252 new_options += ['-l', layer]
1253 else:
1254 new_options += ['-l', layers]
1255 if SQLStatement is not None:
1256 new_options += ['-sql', str(SQLStatement)]
1257 if SQLDialect is not None:
1258 new_options += ['-dialect', str(SQLDialect)]
1259 if where is not None:
1260 new_options += ['-where', str(where)]
1261 if optim is not None:
1262 new_options += ['-optim', str(optim)]
1263 if add:
1264 new_options += ['-add']
1265
1266 return (GDALRasterizeOptions(new_options), callback, callback_data)
1267
1268 -def Rasterize(destNameOrDestDS, srcDS, **kwargs):
1269 """ Burns vector geometries into a raster
1270 Arguments are :
1271 destNameOrDestDS --- Output dataset name or object
1272 srcDS --- a Dataset object or a filename
1273 Keyword arguments are :
1274 options --- return of gdal.RasterizeOptions(), string or array of strings
1275 other keywords arguments of gdal.RasterizeOptions()
1276 If options is provided as a gdal.RasterizeOptions() object, other keywords are ignored. """
1277
1278 if 'options' not in kwargs or isinstance(kwargs['options'], (list, str)):
1279 (opts, callback, callback_data) = RasterizeOptions(**kwargs)
1280 else:
1281 (opts, callback, callback_data) = kwargs['options']
1282 if isinstance(srcDS, str):
1283 srcDS = OpenEx(srcDS, gdalconst.OF_VECTOR)
1284
1285 if isinstance(destNameOrDestDS, str):
1286 return wrapper_GDALRasterizeDestName(destNameOrDestDS, srcDS, opts, callback, callback_data)
1287 else:
1288 return wrapper_GDALRasterizeDestDS(destNameOrDestDS, srcDS, opts, callback, callback_data)
1289
1290
1291 -def BuildVRTOptions(options=None,
1292 resolution=None,
1293 outputBounds=None,
1294 xRes=None, yRes=None,
1295 targetAlignedPixels=None,
1296 separate=None,
1297 bandList=None,
1298 addAlpha=None,
1299 resampleAlg=None,
1300 outputSRS=None,
1301 allowProjectionDifference=None,
1302 srcNodata=None,
1303 VRTNodata=None,
1304 hideNodata=None,
1305 strict=False,
1306 callback=None, callback_data=None):
1307 """ Create a BuildVRTOptions() object that can be passed to gdal.BuildVRT()
1308 Keyword arguments are :
1309 options --- can be be an array of strings, a string or let empty and filled from other keywords..
1310 resolution --- 'highest', 'lowest', 'average', 'user'.
1311 outputBounds --- output bounds as (minX, minY, maxX, maxY) in target SRS.
1312 xRes, yRes --- output resolution in target SRS.
1313 targetAlignedPixels --- whether to force output bounds to be multiple of output resolution.
1314 separate --- whether each source file goes into a separate stacked band in the VRT band.
1315 bandList --- array of band numbers (index start at 1).
1316 addAlpha --- whether to add an alpha mask band to the VRT when the source raster have none.
1317 resampleAlg --- resampling mode.
1318 outputSRS --- assigned output SRS.
1319 allowProjectionDifference --- whether to accept input datasets have not the same projection. Note: they will *not* be reprojected.
1320 srcNodata --- source nodata value(s).
1321 VRTNodata --- nodata values at the VRT band level.
1322 hideNodata --- whether to make the VRT band not report the NoData value.
1323 strict --- set to True if warnings should be failures
1324 callback --- callback method.
1325 callback_data --- user data for callback.
1326 """
1327
1328
1329 return_option_list = options == '__RETURN_OPTION_LIST__'
1330 if return_option_list:
1331 options = []
1332 else:
1333 options = [] if options is None else options
1334
1335 if isinstance(options, str):
1336 new_options = ParseCommandLine(options)
1337 else:
1338 new_options = options
1339 if resolution is not None:
1340 new_options += ['-resolution', str(resolution)]
1341 if outputBounds is not None:
1342 new_options += ['-te', _strHighPrec(outputBounds[0]), _strHighPrec(outputBounds[1]), _strHighPrec(outputBounds[2]), _strHighPrec(outputBounds[3])]
1343 if xRes is not None and yRes is not None:
1344 new_options += ['-tr', _strHighPrec(xRes), _strHighPrec(yRes)]
1345 if targetAlignedPixels:
1346 new_options += ['-tap']
1347 if separate:
1348 new_options += ['-separate']
1349 if bandList != None:
1350 for b in bandList:
1351 new_options += ['-b', str(b)]
1352 if addAlpha:
1353 new_options += ['-addalpha']
1354 if resampleAlg is not None:
1355 if resampleAlg in mapGRIORAMethodToString:
1356 new_options += ['-r', mapGRIORAMethodToString[resampleAlg]]
1357 else:
1358 new_options += ['-r', str(resampleAlg)]
1359 if outputSRS is not None:
1360 new_options += ['-a_srs', str(outputSRS)]
1361 if allowProjectionDifference:
1362 new_options += ['-allow_projection_difference']
1363 if srcNodata is not None:
1364 new_options += ['-srcnodata', str(srcNodata)]
1365 if VRTNodata is not None:
1366 new_options += ['-vrtnodata', str(VRTNodata)]
1367 if hideNodata:
1368 new_options += ['-hidenodata']
1369 if strict:
1370 new_options += ['-strict']
1371
1372 if return_option_list:
1373 return new_options
1374
1375 return (GDALBuildVRTOptions(new_options), callback, callback_data)
1376
1377 -def BuildVRT(destName, srcDSOrSrcDSTab, **kwargs):
1378 """ Build a VRT from a list of datasets.
1379 Arguments are :
1380 destName --- Output dataset name
1381 srcDSOrSrcDSTab --- an array of Dataset objects or filenames, or a Dataset object or a filename
1382 Keyword arguments are :
1383 options --- return of gdal.BuildVRTOptions(), string or array of strings
1384 other keywords arguments of gdal.BuildVRTOptions()
1385 If options is provided as a gdal.BuildVRTOptions() object, other keywords are ignored. """
1386
1387 if 'options' not in kwargs or isinstance(kwargs['options'], (list, str)):
1388 (opts, callback, callback_data) = BuildVRTOptions(**kwargs)
1389 else:
1390 (opts, callback, callback_data) = kwargs['options']
1391
1392 srcDSTab = []
1393 srcDSNamesTab = []
1394 if isinstance(srcDSOrSrcDSTab, str):
1395 srcDSNamesTab = [srcDSOrSrcDSTab]
1396 elif isinstance(srcDSOrSrcDSTab, list):
1397 for elt in srcDSOrSrcDSTab:
1398 if isinstance(elt, str):
1399 srcDSNamesTab.append(elt)
1400 else:
1401 srcDSTab.append(elt)
1402 if srcDSTab and srcDSNamesTab:
1403 raise Exception('Mix of names and dataset objects not supported')
1404 else:
1405 srcDSTab = [srcDSOrSrcDSTab]
1406
1407 if srcDSTab:
1408 return BuildVRTInternalObjects(destName, srcDSTab, opts, callback, callback_data)
1409 else:
1410 return BuildVRTInternalNames(destName, srcDSNamesTab, opts, callback, callback_data)
1411
1412
1413 -def MultiDimTranslateOptions(options=None, format=None, creationOptions=None,
1414 arraySpecs=None, groupSpecs=None, subsetSpecs=None, scaleAxesSpecs=None,
1415 callback=None, callback_data=None):
1416 """ Create a MultiDimTranslateOptions() object that can be passed to gdal.MultiDimTranslate()
1417 Keyword arguments are :
1418 options --- can be be an array of strings, a string or let empty and filled from other keywords.
1419 format --- output format ("GTiff", etc...)
1420 creationOptions --- list of creation options
1421 arraySpecs -- list of array specifications, each of them being an array name or "name={src_array_name},dstname={dst_name},transpose=[1,0],view=[:,::-1]"
1422 groupSpecs -- list of group specifications, each of them being a group name or "name={src_array_name},dstname={dst_name},recursive=no"
1423 subsetSpecs -- list of subset specifications, each of them being like "{dim_name}({min_val},{max_val})" or "{dim_name}({slice_va})"
1424 scaleAxesSpecs -- list of dimension scaling specifications, each of them being like "{dim_name}({scale_factor})"
1425 callback --- callback method
1426 callback_data --- user data for callback
1427 """
1428 options = [] if options is None else options
1429
1430 if isinstance(options, str):
1431 new_options = ParseCommandLine(options)
1432 else:
1433 new_options = options
1434 if format is not None:
1435 new_options += ['-of', format]
1436 if creationOptions is not None:
1437 for opt in creationOptions:
1438 new_options += ['-co', opt]
1439 if arraySpecs is not None:
1440 for s in arraySpecs:
1441 new_options += ['-array', s]
1442 if groupSpecs is not None:
1443 for s in groupSpecs:
1444 new_options += ['-group', s]
1445 if subsetSpecs is not None:
1446 for s in subsetSpecs:
1447 new_options += ['-subset', s]
1448 if scaleAxesSpecs is not None:
1449 for s in scaleAxesSpecs:
1450 new_options += ['-scaleaxes', s]
1451
1452 return (GDALMultiDimTranslateOptions(new_options), callback, callback_data)
1453
1455 """ MultiDimTranslate one or several datasets.
1456 Arguments are :
1457 destName --- Output dataset name
1458 srcDSOrSrcDSTab --- an array of Dataset objects or filenames, or a Dataset object or a filename
1459 Keyword arguments are :
1460 options --- return of gdal.MultiDimTranslateOptions(), string or array of strings
1461 other keywords arguments of gdal.MultiDimTranslateOptions()
1462 If options is provided as a gdal.MultiDimTranslateOptions() object, other keywords are ignored. """
1463
1464 if 'options' not in kwargs or isinstance(kwargs['options'], (list, str)):
1465 (opts, callback, callback_data) = MultiDimTranslateOptions(**kwargs)
1466 else:
1467 (opts, callback, callback_data) = kwargs['options']
1468 if isinstance(srcDSOrSrcDSTab, str):
1469 srcDSTab = [OpenEx(srcDSOrSrcDSTab, OF_VERBOSE_ERROR | OF_RASTER | OF_MULTIDIM_RASTER)]
1470 elif isinstance(srcDSOrSrcDSTab, list):
1471 srcDSTab = []
1472 for elt in srcDSOrSrcDSTab:
1473 if isinstance(elt, str):
1474 srcDSTab.append(OpenEx(elt, OF_VERBOSE_ERROR | OF_RASTER | OF_MULTIDIM_RASTER))
1475 else:
1476 srcDSTab.append(elt)
1477 else:
1478 srcDSTab = [srcDSOrSrcDSTab]
1479
1480 return wrapper_GDALMultiDimTranslateDestName(destName, srcDSTab, opts, callback, callback_data)
1481
1482
1492
1517
1518
1520 """EscapeString(string_or_bytes, scheme = gdal.CPLES_SQL)"""
1521 if isinstance(args[0], bytes):
1522 return _gdal.EscapeBinary(*args, **kwargs)
1523 else:
1524 return _gdal.wrapper_EscapeString(*args, **kwargs)
1525
1526
1528 """ApplyVerticalShiftGrid(Dataset src_ds, Dataset grid_ds, bool inverse=False, double srcUnitToMeter=1.0, double dstUnitToMeter=1.0, char ** options=None) -> Dataset"""
1529
1530 from warnings import warn
1531 warn('ApplyVerticalShiftGrid() will be removed in GDAL 4.0', DeprecationWarning)
1532 return _ApplyVerticalShiftGrid(*args, **kwargs)
1533
1534
1535
1537 """Debug(char const * msg_class, char const * message)"""
1538 return _gdal.Debug(*args)
1539
1541 """SetErrorHandler(CPLErrorHandler pfnErrorHandler=0) -> CPLErr"""
1542 return _gdal.SetErrorHandler(*args)
1543
1547
1549 """PushErrorHandler(CPLErrorHandler pfnErrorHandler=0) -> CPLErr"""
1550 return _gdal.PushErrorHandler(*args)
1551
1555
1557 """Error(CPLErr msg_class, int err_code=0, char const * msg)"""
1558 return _gdal.Error(*args)
1559
1563
1565 """GOA2GetRefreshToken(char const * pszAuthToken, char const * pszScope) -> retStringAndCPLFree *"""
1566 return _gdal.GOA2GetRefreshToken(*args)
1567
1569 """GOA2GetAccessToken(char const * pszRefreshToken, char const * pszScope) -> retStringAndCPLFree *"""
1570 return _gdal.GOA2GetAccessToken(*args)
1571
1575
1577 """wrapper_EscapeString(int len, int scheme) -> retStringAndCPLFree *"""
1578 return _gdal.wrapper_EscapeString(*args, **kwargs)
1579
1581 """EscapeBinary(int len, int scheme)"""
1582 return _gdal.EscapeBinary(*args, **kwargs)
1583
1587
1591
1595
1599
1603
1607
1611
1615
1619
1623
1625 """FindFile(char const * pszClass, char const * utf8_path) -> char const *"""
1626 return _gdal.FindFile(*args)
1627
1629 """ReadDir(char const * utf8_path, int nMaxFiles=0) -> char **"""
1630 return _gdal.ReadDir(*args)
1631
1635
1637 """OpenDir(char const * utf8_path, int nRecurseDepth=-1, char ** options=None) -> VSIDIR *"""
1638 return _gdal.OpenDir(*args)
1639 -class DirEntry(_object):
1640 """Proxy of C++ DirEntry class."""
1641
1642 __swig_setmethods__ = {}
1643 __setattr__ = lambda self, name, value: _swig_setattr(self, DirEntry, name, value)
1644 __swig_getmethods__ = {}
1645 __getattr__ = lambda self, name: _swig_getattr(self, DirEntry, name)
1646 __repr__ = _swig_repr
1647 __swig_getmethods__["name"] = _gdal.DirEntry_name_get
1648 if _newclass:
1649 name = _swig_property(_gdal.DirEntry_name_get)
1650 __swig_getmethods__["mode"] = _gdal.DirEntry_mode_get
1651 if _newclass:
1652 mode = _swig_property(_gdal.DirEntry_mode_get)
1653 __swig_getmethods__["size"] = _gdal.DirEntry_size_get
1654 if _newclass:
1655 size = _swig_property(_gdal.DirEntry_size_get)
1656 __swig_getmethods__["mtime"] = _gdal.DirEntry_mtime_get
1657 if _newclass:
1658 mtime = _swig_property(_gdal.DirEntry_mtime_get)
1659 __swig_getmethods__["modeKnown"] = _gdal.DirEntry_modeKnown_get
1660 if _newclass:
1661 modeKnown = _swig_property(_gdal.DirEntry_modeKnown_get)
1662 __swig_getmethods__["sizeKnown"] = _gdal.DirEntry_sizeKnown_get
1663 if _newclass:
1664 sizeKnown = _swig_property(_gdal.DirEntry_sizeKnown_get)
1665 __swig_getmethods__["mtimeKnown"] = _gdal.DirEntry_mtimeKnown_get
1666 if _newclass:
1667 mtimeKnown = _swig_property(_gdal.DirEntry_mtimeKnown_get)
1668 __swig_getmethods__["extra"] = _gdal.DirEntry_extra_get
1669 if _newclass:
1670 extra = _swig_property(_gdal.DirEntry_extra_get)
1671
1672 - def __init__(self, *args):
1673 """__init__(DirEntry self, DirEntry entryIn) -> DirEntry"""
1674 this = _gdal.new_DirEntry(*args)
1675 try:
1676 self.this.append(this)
1677 except __builtin__.Exception:
1678 self.this = this
1679 __swig_destroy__ = _gdal.delete_DirEntry
1680 __del__ = lambda self: None
1681
1682 - def IsDirectory(self, *args):
1683 """IsDirectory(DirEntry self) -> bool"""
1684 return _gdal.DirEntry_IsDirectory(self, *args)
1685
1686 DirEntry_swigregister = _gdal.DirEntry_swigregister
1687 DirEntry_swigregister(DirEntry)
1688
1689
1690 -def GetNextDirEntry(*args):
1691 """GetNextDirEntry(VSIDIR * dir) -> DirEntry"""
1692 return _gdal.GetNextDirEntry(*args)
1693
1695 """CloseDir(VSIDIR * dir)"""
1696 return _gdal.CloseDir(*args)
1697
1699 """SetConfigOption(char const * pszKey, char const * pszValue)"""
1700 return _gdal.SetConfigOption(*args)
1701
1705
1707 """GetConfigOption(char const * pszKey, char const * pszDefault=None) -> char const *"""
1708 return _gdal.GetConfigOption(*args)
1709
1711 """GetThreadLocalConfigOption(char const * pszKey, char const * pszDefault=None) -> char const *"""
1712 return _gdal.GetThreadLocalConfigOption(*args)
1713
1715 """SetCredential(char const * pszPathPrefix, char const * pszKey, char const * pszValue)"""
1716 return _gdal.SetCredential(*args)
1717
1719 """GetCredential(char const * pszPathPrefix, char const * pszKey, char const * pszDefault=None) -> char const *"""
1720 return _gdal.GetCredential(*args)
1721
1725
1727 """CPLBinaryToHex(int nBytes) -> retStringAndCPLFree *"""
1728 return _gdal.CPLBinaryToHex(*args)
1729
1731 """CPLHexToBinary(char const * pszHex, int * pnBytes) -> GByte *"""
1732 return _gdal.CPLHexToBinary(*args)
1733
1735 """FileFromMemBuffer(char const * utf8_path, GIntBig nBytes)"""
1736 return _gdal.FileFromMemBuffer(*args)
1737
1739 """Unlink(char const * utf8_path) -> VSI_RETVAL"""
1740 return _gdal.Unlink(*args)
1741
1743 """UnlinkBatch(char ** files) -> bool"""
1744 return _gdal.UnlinkBatch(*args)
1745
1749
1751 """Mkdir(char const * utf8_path, int mode) -> VSI_RETVAL"""
1752 return _gdal.Mkdir(*args)
1753
1755 """Rmdir(char const * utf8_path) -> VSI_RETVAL"""
1756 return _gdal.Rmdir(*args)
1757
1759 """MkdirRecursive(char const * utf8_path, int mode) -> VSI_RETVAL"""
1760 return _gdal.MkdirRecursive(*args)
1761
1763 """RmdirRecursive(char const * utf8_path) -> VSI_RETVAL"""
1764 return _gdal.RmdirRecursive(*args)
1765
1767 """Rename(char const * pszOld, char const * pszNew) -> VSI_RETVAL"""
1768 return _gdal.Rename(*args)
1769
1770 -def Sync(*args, **kwargs):
1771 """Sync(char const * pszSource, char const * pszTarget, char ** options=None, GDALProgressFunc callback=0, void * callback_data=None) -> bool"""
1772 return _gdal.Sync(*args, **kwargs)
1773
1777
1779 """GetActualURL(char const * utf8_path) -> char const *"""
1780 return _gdal.GetActualURL(*args)
1781
1783 """GetSignedURL(char const * utf8_path, char ** options=None) -> retStringAndCPLFree *"""
1784 return _gdal.GetSignedURL(*args)
1785
1789
1804 VSILFILE_swigregister = _gdal.VSILFILE_swigregister
1805 VSILFILE_swigregister(VSILFILE)
1806
1807 VSI_STAT_EXISTS_FLAG = _gdal.VSI_STAT_EXISTS_FLAG
1808 VSI_STAT_NATURE_FLAG = _gdal.VSI_STAT_NATURE_FLAG
1809 VSI_STAT_SIZE_FLAG = _gdal.VSI_STAT_SIZE_FLAG
1810 VSI_STAT_SET_ERROR_FLAG = _gdal.VSI_STAT_SET_ERROR_FLAG
1811 VSI_STAT_CACHE_ONLY = _gdal.VSI_STAT_CACHE_ONLY
1813 """Proxy of C++ StatBuf class."""
1814
1815 __swig_setmethods__ = {}
1816 __setattr__ = lambda self, name, value: _swig_setattr(self, StatBuf, name, value)
1817 __swig_getmethods__ = {}
1818 __getattr__ = lambda self, name: _swig_getattr(self, StatBuf, name)
1819 __repr__ = _swig_repr
1820 __swig_getmethods__["mode"] = _gdal.StatBuf_mode_get
1821 if _newclass:
1822 mode = _swig_property(_gdal.StatBuf_mode_get)
1823 __swig_getmethods__["size"] = _gdal.StatBuf_size_get
1824 if _newclass:
1825 size = _swig_property(_gdal.StatBuf_size_get)
1826 __swig_getmethods__["mtime"] = _gdal.StatBuf_mtime_get
1827 if _newclass:
1828 mtime = _swig_property(_gdal.StatBuf_mtime_get)
1829
1831 """__init__(StatBuf self, StatBuf psStatBuf) -> StatBuf"""
1832 this = _gdal.new_StatBuf(*args)
1833 try:
1834 self.this.append(this)
1835 except __builtin__.Exception:
1836 self.this = this
1837 __swig_destroy__ = _gdal.delete_StatBuf
1838 __del__ = lambda self: None
1839
1841 """IsDirectory(StatBuf self) -> int"""
1842 return _gdal.StatBuf_IsDirectory(self, *args)
1843
1844 StatBuf_swigregister = _gdal.StatBuf_swigregister
1845 StatBuf_swigregister(StatBuf)
1846
1847
1849 """VSIStatL(char const * utf8_path, int nFlags=0) -> int"""
1850 return _gdal.VSIStatL(*args)
1851
1855
1859
1861 """VSIFOpenL(char const * utf8_path, char const * pszMode) -> VSILFILE"""
1862 return _gdal.VSIFOpenL(*args)
1863
1865 """VSIFOpenExL(char const * utf8_path, char const * pszMode, int bSetError=False, char ** options=None) -> VSILFILE"""
1866 return _gdal.VSIFOpenExL(*args)
1867
1869 """VSIFEofL(VSILFILE fp) -> int"""
1870 return _gdal.VSIFEofL(*args)
1871
1873 """VSIFFlushL(VSILFILE fp) -> int"""
1874 return _gdal.VSIFFlushL(*args)
1875
1877 """VSIFCloseL(VSILFILE fp) -> VSI_RETVAL"""
1878 return _gdal.VSIFCloseL(*args)
1879
1881 """VSIFSeekL(VSILFILE fp, GIntBig offset, int whence) -> int"""
1882 return _gdal.VSIFSeekL(*args)
1883
1885 """VSIFTellL(VSILFILE fp) -> GIntBig"""
1886 return _gdal.VSIFTellL(*args)
1887
1889 """VSIFTruncateL(VSILFILE fp, GIntBig length) -> int"""
1890 return _gdal.VSIFTruncateL(*args)
1891
1895 VSI_RANGE_STATUS_UNKNOWN = _gdal.VSI_RANGE_STATUS_UNKNOWN
1896 VSI_RANGE_STATUS_DATA = _gdal.VSI_RANGE_STATUS_DATA
1897 VSI_RANGE_STATUS_HOLE = _gdal.VSI_RANGE_STATUS_HOLE
1898
1900 """VSIFGetRangeStatusL(VSILFILE fp, GIntBig offset, GIntBig length) -> int"""
1901 return _gdal.VSIFGetRangeStatusL(*args)
1902
1904 """VSIFWriteL(int nLen, int size, int memb, VSILFILE fp) -> int"""
1905 return _gdal.VSIFWriteL(*args)
1906
1910
1914
1918
1922
1927 """Proxy of C++ GDALMajorObjectShadow class."""
1928
1929 __swig_setmethods__ = {}
1930 __setattr__ = lambda self, name, value: _swig_setattr(self, MajorObject, name, value)
1931 __swig_getmethods__ = {}
1932 __getattr__ = lambda self, name: _swig_getattr(self, MajorObject, name)
1933
1935 raise AttributeError("No constructor defined")
1936 __repr__ = _swig_repr
1937
1939 """GetDescription(MajorObject self) -> char const *"""
1940 return _gdal.MajorObject_GetDescription(self, *args)
1941
1942
1944 """SetDescription(MajorObject self, char const * pszNewDesc)"""
1945 return _gdal.MajorObject_SetDescription(self, *args)
1946
1947
1949 """GetMetadataDomainList(MajorObject self) -> char **"""
1950 return _gdal.MajorObject_GetMetadataDomainList(self, *args)
1951
1952
1956
1957
1961
1962
1969
1970
1974
1975
1979
1980
1985
1986 MajorObject_swigregister = _gdal.MajorObject_swigregister
1987 MajorObject_swigregister(MajorObject)
1988
1990 """Proxy of C++ GDALDriverShadow class."""
1991
1992 __swig_setmethods__ = {}
1993 for _s in [MajorObject]:
1994 __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
1995 __setattr__ = lambda self, name, value: _swig_setattr(self, Driver, name, value)
1996 __swig_getmethods__ = {}
1997 for _s in [MajorObject]:
1998 __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
1999 __getattr__ = lambda self, name: _swig_getattr(self, Driver, name)
2000
2002 raise AttributeError("No constructor defined")
2003 __repr__ = _swig_repr
2004 __swig_getmethods__["ShortName"] = _gdal.Driver_ShortName_get
2005 if _newclass:
2006 ShortName = _swig_property(_gdal.Driver_ShortName_get)
2007 __swig_getmethods__["LongName"] = _gdal.Driver_LongName_get
2008 if _newclass:
2009 LongName = _swig_property(_gdal.Driver_LongName_get)
2010 __swig_getmethods__["HelpTopic"] = _gdal.Driver_HelpTopic_get
2011 if _newclass:
2012 HelpTopic = _swig_property(_gdal.Driver_HelpTopic_get)
2013
2014 - def Create(self, *args, **kwargs):
2015 """Create(Driver self, char const * utf8_path, int xsize, int ysize, int bands=1, GDALDataType eType, char ** options=None) -> Dataset"""
2016 return _gdal.Driver_Create(self, *args, **kwargs)
2017
2018
2020 """CreateMultiDimensional(Driver self, char const * utf8_path, char ** root_group_options=None, char ** options=None) -> Dataset"""
2021 return _gdal.Driver_CreateMultiDimensional(self, *args, **kwargs)
2022
2023
2025 """CreateCopy(Driver self, char const * utf8_path, Dataset src, int strict=1, char ** options=None, GDALProgressFunc callback=0, void * callback_data=None) -> Dataset"""
2026 return _gdal.Driver_CreateCopy(self, *args, **kwargs)
2027
2028
2030 """Delete(Driver self, char const * utf8_path) -> CPLErr"""
2031 return _gdal.Driver_Delete(self, *args)
2032
2033
2035 """Rename(Driver self, char const * newName, char const * oldName) -> CPLErr"""
2036 return _gdal.Driver_Rename(self, *args)
2037
2038
2040 """CopyFiles(Driver self, char const * newName, char const * oldName) -> CPLErr"""
2041 return _gdal.Driver_CopyFiles(self, *args)
2042
2043
2045 """Register(Driver self) -> int"""
2046 return _gdal.Driver_Register(self, *args)
2047
2048
2050 """Deregister(Driver self)"""
2051 return _gdal.Driver_Deregister(self, *args)
2052
2053 Driver_swigregister = _gdal.Driver_swigregister
2054 Driver_swigregister(Driver)
2055
2056 from sys import version_info as _swig_python_version_info
2057 if _swig_python_version_info >= (2, 7, 0):
2058 from . import ogr
2059 else:
2060 import ogr
2061 del _swig_python_version_info
2062 from sys import version_info as _swig_python_version_info
2063 if _swig_python_version_info >= (2, 7, 0):
2064 from . import osr
2065 else:
2066 import osr
2067 del _swig_python_version_info
2068 -class ColorEntry(_object):
2069 """Proxy of C++ GDALColorEntry class."""
2070
2071 __swig_setmethods__ = {}
2072 __setattr__ = lambda self, name, value: _swig_setattr(self, ColorEntry, name, value)
2073 __swig_getmethods__ = {}
2074 __getattr__ = lambda self, name: _swig_getattr(self, ColorEntry, name)
2075
2076 - def __init__(self, *args, **kwargs):
2077 raise AttributeError("No constructor defined")
2078 __repr__ = _swig_repr
2079 __swig_setmethods__["c1"] = _gdal.ColorEntry_c1_set
2080 __swig_getmethods__["c1"] = _gdal.ColorEntry_c1_get
2081 if _newclass:
2082 c1 = _swig_property(_gdal.ColorEntry_c1_get, _gdal.ColorEntry_c1_set)
2083 __swig_setmethods__["c2"] = _gdal.ColorEntry_c2_set
2084 __swig_getmethods__["c2"] = _gdal.ColorEntry_c2_get
2085 if _newclass:
2086 c2 = _swig_property(_gdal.ColorEntry_c2_get, _gdal.ColorEntry_c2_set)
2087 __swig_setmethods__["c3"] = _gdal.ColorEntry_c3_set
2088 __swig_getmethods__["c3"] = _gdal.ColorEntry_c3_get
2089 if _newclass:
2090 c3 = _swig_property(_gdal.ColorEntry_c3_get, _gdal.ColorEntry_c3_set)
2091 __swig_setmethods__["c4"] = _gdal.ColorEntry_c4_set
2092 __swig_getmethods__["c4"] = _gdal.ColorEntry_c4_get
2093 if _newclass:
2094 c4 = _swig_property(_gdal.ColorEntry_c4_get, _gdal.ColorEntry_c4_set)
2095 ColorEntry_swigregister = _gdal.ColorEntry_swigregister
2096 ColorEntry_swigregister(ColorEntry)
2097
2098 -class GCP(_object):
2099 """Proxy of C++ GDAL_GCP class."""
2100
2101 __swig_setmethods__ = {}
2102 __setattr__ = lambda self, name, value: _swig_setattr(self, GCP, name, value)
2103 __swig_getmethods__ = {}
2104 __getattr__ = lambda self, name: _swig_getattr(self, GCP, name)
2105 __repr__ = _swig_repr
2106 __swig_setmethods__["GCPX"] = _gdal.GCP_GCPX_set
2107 __swig_getmethods__["GCPX"] = _gdal.GCP_GCPX_get
2108 if _newclass:
2109 GCPX = _swig_property(_gdal.GCP_GCPX_get, _gdal.GCP_GCPX_set)
2110 __swig_setmethods__["GCPY"] = _gdal.GCP_GCPY_set
2111 __swig_getmethods__["GCPY"] = _gdal.GCP_GCPY_get
2112 if _newclass:
2113 GCPY = _swig_property(_gdal.GCP_GCPY_get, _gdal.GCP_GCPY_set)
2114 __swig_setmethods__["GCPZ"] = _gdal.GCP_GCPZ_set
2115 __swig_getmethods__["GCPZ"] = _gdal.GCP_GCPZ_get
2116 if _newclass:
2117 GCPZ = _swig_property(_gdal.GCP_GCPZ_get, _gdal.GCP_GCPZ_set)
2118 __swig_setmethods__["GCPPixel"] = _gdal.GCP_GCPPixel_set
2119 __swig_getmethods__["GCPPixel"] = _gdal.GCP_GCPPixel_get
2120 if _newclass:
2121 GCPPixel = _swig_property(_gdal.GCP_GCPPixel_get, _gdal.GCP_GCPPixel_set)
2122 __swig_setmethods__["GCPLine"] = _gdal.GCP_GCPLine_set
2123 __swig_getmethods__["GCPLine"] = _gdal.GCP_GCPLine_get
2124 if _newclass:
2125 GCPLine = _swig_property(_gdal.GCP_GCPLine_get, _gdal.GCP_GCPLine_set)
2126 __swig_setmethods__["Info"] = _gdal.GCP_Info_set
2127 __swig_getmethods__["Info"] = _gdal.GCP_Info_get
2128 if _newclass:
2129 Info = _swig_property(_gdal.GCP_Info_get, _gdal.GCP_Info_set)
2130 __swig_setmethods__["Id"] = _gdal.GCP_Id_set
2131 __swig_getmethods__["Id"] = _gdal.GCP_Id_get
2132 if _newclass:
2133 Id = _swig_property(_gdal.GCP_Id_get, _gdal.GCP_Id_set)
2134
2136 """__init__(GDAL_GCP self, double x=0.0, double y=0.0, double z=0.0, double pixel=0.0, double line=0.0, char const * info, char const * id) -> GCP"""
2137 this = _gdal.new_GCP(*args)
2138 try:
2139 self.this.append(this)
2140 except __builtin__.Exception:
2141 self.this = this
2142 __swig_destroy__ = _gdal.delete_GCP
2143 __del__ = lambda self: None
2144
2146 str = '%s (%.2fP,%.2fL) -> (%.7fE,%.7fN,%.2f) %s '\
2147 % (self.Id, self.GCPPixel, self.GCPLine,
2148 self.GCPX, self.GCPY, self.GCPZ, self.Info )
2149 return str
2150
2152 base = [gdalconst.CXT_Element,'GCP']
2153 base.append([gdalconst.CXT_Attribute,'Id',[gdalconst.CXT_Text,self.Id]])
2154 pixval = '%0.15E' % self.GCPPixel
2155 lineval = '%0.15E' % self.GCPLine
2156 xval = '%0.15E' % self.GCPX
2157 yval = '%0.15E' % self.GCPY
2158 zval = '%0.15E' % self.GCPZ
2159 base.append([gdalconst.CXT_Attribute,'Pixel',[gdalconst.CXT_Text,pixval]])
2160 base.append([gdalconst.CXT_Attribute,'Line',[gdalconst.CXT_Text,lineval]])
2161 base.append([gdalconst.CXT_Attribute,'X',[gdalconst.CXT_Text,xval]])
2162 base.append([gdalconst.CXT_Attribute,'Y',[gdalconst.CXT_Text,yval]])
2163 if with_Z:
2164 base.append([gdalconst.CXT_Attribute,'Z',[gdalconst.CXT_Text,zval]])
2165 return base
2166
2167 GCP_swigregister = _gdal.GCP_swigregister
2168 GCP_swigregister(GCP)
2169
2170
2174
2178
2182
2186
2190
2194
2198
2202
2206
2210
2214
2218
2222
2226
2231 """Proxy of C++ CPLVirtualMemShadow class."""
2232
2233 __swig_setmethods__ = {}
2234 __setattr__ = lambda self, name, value: _swig_setattr(self, VirtualMem, name, value)
2235 __swig_getmethods__ = {}
2236 __getattr__ = lambda self, name: _swig_getattr(self, VirtualMem, name)
2237
2239 raise AttributeError("No constructor defined")
2240 __repr__ = _swig_repr
2241 __swig_destroy__ = _gdal.delete_VirtualMem
2242 __del__ = lambda self: None
2243
2245 """GetAddr(VirtualMem self)"""
2246 return _gdal.VirtualMem_GetAddr(self, *args)
2247
2248
2249 - def Pin(self, *args):
2250 """Pin(VirtualMem self, size_t start_offset=0, size_t nsize=0, int bWriteOp=0)"""
2251 return _gdal.VirtualMem_Pin(self, *args)
2252
2253 VirtualMem_swigregister = _gdal.VirtualMem_swigregister
2254 VirtualMem_swigregister(VirtualMem)
2255
2257 """Proxy of C++ GDALAsyncReaderShadow class."""
2258
2259 __swig_setmethods__ = {}
2260 __setattr__ = lambda self, name, value: _swig_setattr(self, AsyncReader, name, value)
2261 __swig_getmethods__ = {}
2262 __getattr__ = lambda self, name: _swig_getattr(self, AsyncReader, name)
2263
2265 raise AttributeError("No constructor defined")
2266 __repr__ = _swig_repr
2267 __swig_destroy__ = _gdal.delete_AsyncReader
2268 __del__ = lambda self: None
2269
2271 """GetNextUpdatedRegion(AsyncReader self, double timeout) -> GDALAsyncStatusType"""
2272 return _gdal.AsyncReader_GetNextUpdatedRegion(self, *args)
2273
2274
2276 """GetBuffer(AsyncReader self)"""
2277 return _gdal.AsyncReader_GetBuffer(self, *args)
2278
2279
2281 """LockBuffer(AsyncReader self, double timeout) -> int"""
2282 return _gdal.AsyncReader_LockBuffer(self, *args)
2283
2284
2286 """UnlockBuffer(AsyncReader self)"""
2287 return _gdal.AsyncReader_UnlockBuffer(self, *args)
2288
2289 AsyncReader_swigregister = _gdal.AsyncReader_swigregister
2290 AsyncReader_swigregister(AsyncReader)
2291
2293 """Proxy of C++ GDALDatasetShadow class."""
2294
2295 __swig_setmethods__ = {}
2296 for _s in [MajorObject]:
2297 __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
2298 __setattr__ = lambda self, name, value: _swig_setattr(self, Dataset, name, value)
2299 __swig_getmethods__ = {}
2300 for _s in [MajorObject]:
2301 __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
2302 __getattr__ = lambda self, name: _swig_getattr(self, Dataset, name)
2303
2305 raise AttributeError("No constructor defined")
2306 __repr__ = _swig_repr
2307 __swig_getmethods__["RasterXSize"] = _gdal.Dataset_RasterXSize_get
2308 if _newclass:
2309 RasterXSize = _swig_property(_gdal.Dataset_RasterXSize_get)
2310 __swig_getmethods__["RasterYSize"] = _gdal.Dataset_RasterYSize_get
2311 if _newclass:
2312 RasterYSize = _swig_property(_gdal.Dataset_RasterYSize_get)
2313 __swig_getmethods__["RasterCount"] = _gdal.Dataset_RasterCount_get
2314 if _newclass:
2315 RasterCount = _swig_property(_gdal.Dataset_RasterCount_get)
2316 __swig_destroy__ = _gdal.delete_Dataset
2317 __del__ = lambda self: None
2318
2320 """GetDriver(Dataset self) -> Driver"""
2321 return _gdal.Dataset_GetDriver(self, *args)
2322
2323
2325 """GetRasterBand(Dataset self, int nBand) -> Band"""
2326 return _gdal.Dataset_GetRasterBand(self, *args)
2327
2328
2330 """GetRootGroup(Dataset self) -> Group"""
2331 return _gdal.Dataset_GetRootGroup(self, *args)
2332
2333
2335 """GetProjection(Dataset self) -> char const *"""
2336 return _gdal.Dataset_GetProjection(self, *args)
2337
2338
2340 """GetProjectionRef(Dataset self) -> char const *"""
2341 return _gdal.Dataset_GetProjectionRef(self, *args)
2342
2343
2345 """GetSpatialRef(Dataset self) -> SpatialReference"""
2346 return _gdal.Dataset_GetSpatialRef(self, *args)
2347
2348
2350 """SetProjection(Dataset self, char const * prj) -> CPLErr"""
2351 return _gdal.Dataset_SetProjection(self, *args)
2352
2353
2355 """SetSpatialRef(Dataset self, SpatialReference srs) -> CPLErr"""
2356 return _gdal.Dataset_SetSpatialRef(self, *args)
2357
2358
2362
2363
2367
2368
2370 """BuildOverviews(Dataset self, char const * resampling, int overviewlist=0, GDALProgressFunc callback=0, void * callback_data=None) -> int"""
2371 return _gdal.Dataset_BuildOverviews(self, *args, **kwargs)
2372
2373
2375 """GetGCPCount(Dataset self) -> int"""
2376 return _gdal.Dataset_GetGCPCount(self, *args)
2377
2378
2380 """GetGCPProjection(Dataset self) -> char const *"""
2381 return _gdal.Dataset_GetGCPProjection(self, *args)
2382
2383
2385 """GetGCPSpatialRef(Dataset self) -> SpatialReference"""
2386 return _gdal.Dataset_GetGCPSpatialRef(self, *args)
2387
2388
2390 """GetGCPs(Dataset self)"""
2391 return _gdal.Dataset_GetGCPs(self, *args)
2392
2393
2395 """_SetGCPs(Dataset self, int nGCPs, char const * pszGCPProjection) -> CPLErr"""
2396 return _gdal.Dataset__SetGCPs(self, *args)
2397
2398
2400 """_SetGCPs2(Dataset self, int nGCPs, SpatialReference hSRS) -> CPLErr"""
2401 return _gdal.Dataset__SetGCPs2(self, *args)
2402
2403
2405 """FlushCache(Dataset self)"""
2406 return _gdal.Dataset_FlushCache(self, *args)
2407
2408
2409 - def AddBand(self, *args, **kwargs):
2410 """AddBand(Dataset self, GDALDataType datatype, char ** options=None) -> CPLErr"""
2411 return _gdal.Dataset_AddBand(self, *args, **kwargs)
2412
2413
2415 """CreateMaskBand(Dataset self, int nFlags) -> CPLErr"""
2416 return _gdal.Dataset_CreateMaskBand(self, *args)
2417
2418
2420 """GetFileList(Dataset self) -> char **"""
2421 return _gdal.Dataset_GetFileList(self, *args)
2422
2423
2425 """WriteRaster(Dataset self, int xoff, int yoff, int xsize, int ysize, GIntBig buf_len, int * buf_xsize=None, int * buf_ysize=None, GDALDataType * buf_type=None, int band_list=0, GIntBig * buf_pixel_space=None, GIntBig * buf_line_space=None, GIntBig * buf_band_space=None) -> CPLErr"""
2426 return _gdal.Dataset_WriteRaster(self, *args, **kwargs)
2427
2428
2430 """AdviseRead(Dataset self, int xoff, int yoff, int xsize, int ysize, int * buf_xsize=None, int * buf_ysize=None, GDALDataType * buf_type=None, int band_list=0, char ** options=None) -> CPLErr"""
2431 return _gdal.Dataset_AdviseRead(self, *args)
2432
2433
2435 """BeginAsyncReader(Dataset self, int xOff, int yOff, int xSize, int ySize, int buf_len, int buf_xsize, int buf_ysize, GDALDataType bufType, int band_list=0, int nPixelSpace=0, int nLineSpace=0, int nBandSpace=0, char ** options=None) -> AsyncReader"""
2436 return _gdal.Dataset_BeginAsyncReader(self, *args, **kwargs)
2437
2438
2440 """EndAsyncReader(Dataset self, AsyncReader ario)"""
2441 return _gdal.Dataset_EndAsyncReader(self, *args)
2442
2443
2445 """GetVirtualMem(Dataset self, GDALRWFlag eRWFlag, int nXOff, int nYOff, int nXSize, int nYSize, int nBufXSize, int nBufYSize, GDALDataType eBufType, int band_list, int bIsBandSequential, size_t nCacheSize, size_t nPageSizeHint, char ** options=None) -> VirtualMem"""
2446 return _gdal.Dataset_GetVirtualMem(self, *args, **kwargs)
2447
2448
2450 """GetTiledVirtualMem(Dataset self, GDALRWFlag eRWFlag, int nXOff, int nYOff, int nXSize, int nYSize, int nTileXSize, int nTileYSize, GDALDataType eBufType, int band_list, GDALTileOrganization eTileOrganization, size_t nCacheSize, char ** options=None) -> VirtualMem"""
2451 return _gdal.Dataset_GetTiledVirtualMem(self, *args, **kwargs)
2452
2453
2455 """CreateLayer(Dataset self, char const * name, SpatialReference srs=None, OGRwkbGeometryType geom_type, char ** options=None) -> Layer"""
2456 return _gdal.Dataset_CreateLayer(self, *args, **kwargs)
2457
2458
2460 """CopyLayer(Dataset self, Layer src_layer, char const * new_name, char ** options=None) -> Layer"""
2461 return _gdal.Dataset_CopyLayer(self, *args, **kwargs)
2462
2463
2465 """DeleteLayer(Dataset self, int index) -> OGRErr"""
2466 return _gdal.Dataset_DeleteLayer(self, *args)
2467
2468
2470 """GetLayerCount(Dataset self) -> int"""
2471 return _gdal.Dataset_GetLayerCount(self, *args)
2472
2473
2475 """IsLayerPrivate(Dataset self, int index) -> bool"""
2476 return _gdal.Dataset_IsLayerPrivate(self, *args)
2477
2478
2480 """GetLayerByIndex(Dataset self, int index=0) -> Layer"""
2481 return _gdal.Dataset_GetLayerByIndex(self, *args)
2482
2483
2485 """GetLayerByName(Dataset self, char const * layer_name) -> Layer"""
2486 return _gdal.Dataset_GetLayerByName(self, *args)
2487
2488
2490 """ResetReading(Dataset self)"""
2491 return _gdal.Dataset_ResetReading(self, *args)
2492
2493
2495 """GetNextFeature(Dataset self, bool include_layer=True, bool include_pct=False, GDALProgressFunc callback=0, void * callback_data=None) -> Feature"""
2496 return _gdal.Dataset_GetNextFeature(self, *args, **kwargs)
2497
2498
2500 """TestCapability(Dataset self, char const * cap) -> bool"""
2501 return _gdal.Dataset_TestCapability(self, *args)
2502
2503
2505 """ExecuteSQL(Dataset self, char const * statement, Geometry spatialFilter=None, char const * dialect) -> Layer"""
2506 return _gdal.Dataset_ExecuteSQL(self, *args, **kwargs)
2507
2508
2510 """ReleaseResultSet(Dataset self, Layer layer)"""
2511 return _gdal.Dataset_ReleaseResultSet(self, *args)
2512
2513
2515 """GetStyleTable(Dataset self) -> StyleTable"""
2516 return _gdal.Dataset_GetStyleTable(self, *args)
2517
2518
2520 """SetStyleTable(Dataset self, StyleTable table)"""
2521 return _gdal.Dataset_SetStyleTable(self, *args)
2522
2523
2525 """AbortSQL(Dataset self) -> OGRErr"""
2526 return _gdal.Dataset_AbortSQL(self, *args)
2527
2528
2530 """StartTransaction(Dataset self, int force=False) -> OGRErr"""
2531 return _gdal.Dataset_StartTransaction(self, *args, **kwargs)
2532
2533
2535 """CommitTransaction(Dataset self) -> OGRErr"""
2536 return _gdal.Dataset_CommitTransaction(self, *args)
2537
2538
2540 """RollbackTransaction(Dataset self) -> OGRErr"""
2541 return _gdal.Dataset_RollbackTransaction(self, *args)
2542
2543
2545 """ClearStatistics(Dataset self)"""
2546 return _gdal.Dataset_ClearStatistics(self, *args)
2547
2548
2549 - def GetFieldDomainNames(self, *args):
2550 """GetFieldDomainNames(Dataset self, char ** options=None) -> char **"""
2551 return _gdal.Dataset_GetFieldDomainNames(self, *args)
2552
2553
2554 - def GetFieldDomain(self, *args):
2555 """GetFieldDomain(Dataset self, char const * name) -> FieldDomain"""
2556 return _gdal.Dataset_GetFieldDomain(self, *args)
2557
2558
2559 - def AddFieldDomain(self, *args):
2560 """AddFieldDomain(Dataset self, FieldDomain fieldDomain) -> bool"""
2561 return _gdal.Dataset_AddFieldDomain(self, *args)
2562
2563
2564 - def DeleteFieldDomain(self, *args):
2565 """DeleteFieldDomain(Dataset self, char const * name) -> bool"""
2566 return _gdal.Dataset_DeleteFieldDomain(self, *args)
2567
2568
2569 - def UpdateFieldDomain(self, *args):
2570 """UpdateFieldDomain(Dataset self, FieldDomain fieldDomain) -> bool"""
2571 return _gdal.Dataset_UpdateFieldDomain(self, *args)
2572
2573
2575 """ReadRaster1(Dataset self, double xoff, double yoff, double xsize, double ysize, int * buf_xsize=None, int * buf_ysize=None, GDALDataType * buf_type=None, int band_list=0, GIntBig * buf_pixel_space=None, GIntBig * buf_line_space=None, GIntBig * buf_band_space=None, GDALRIOResampleAlg resample_alg, GDALProgressFunc callback=0, void * callback_data=None, void * inputOutputBuf=None) -> CPLErr"""
2576 return _gdal.Dataset_ReadRaster1(self, *args, **kwargs)
2577
2578
2579
2580 - def ReadAsArray(self, xoff=0, yoff=0, xsize=None, ysize=None, buf_obj=None,
2581 buf_xsize=None, buf_ysize=None, buf_type=None,
2582 resample_alg=gdalconst.GRIORA_NearestNeighbour,
2583 callback=None,
2584 callback_data=None,
2585 interleave='band',
2586 band_list=None):
2587 """ Reading a chunk of a GDAL band into a numpy array. The optional (buf_xsize,buf_ysize,buf_type)
2588 parameters should generally not be specified if buf_obj is specified. The array is returned"""
2589
2590 from osgeo import gdal_array
2591 return gdal_array.DatasetReadAsArray(self, xoff, yoff, xsize, ysize, buf_obj,
2592 buf_xsize, buf_ysize, buf_type,
2593 resample_alg=resample_alg,
2594 callback=callback,
2595 callback_data=callback_data,
2596 interleave=interleave,
2597 band_list=band_list)
2598
2605 from osgeo import gdal_array
2606
2607 return gdal_array.DatasetWriteArray(self, array, xoff, yoff,
2608 band_list=band_list,
2609 interleave=interleave,
2610 resample_alg=resample_alg,
2611 callback=callback,
2612 callback_data=callback_data)
2613
2614 - def WriteRaster(self, xoff, yoff, xsize, ysize,
2615 buf_string,
2616 buf_xsize=None, buf_ysize=None, buf_type=None,
2617 band_list=None,
2618 buf_pixel_space=None, buf_line_space=None, buf_band_space=None ):
2619
2620 if buf_xsize is None:
2621 buf_xsize = xsize
2622 if buf_ysize is None:
2623 buf_ysize = ysize
2624 if band_list is None:
2625 band_list = list(range(1, self.RasterCount + 1))
2626
2627
2628
2629 if type(buf_string).__name__ == 'ndarray' and \
2630 buf_xsize == xsize and buf_ysize == ysize and buf_type is None and \
2631 buf_pixel_space is None and buf_line_space is None and buf_band_space is None:
2632 return self.WriteArray(buf_string, xoff=xoff, yoff=yoff,
2633 band_list=band_list)
2634 if buf_type is None:
2635 buf_type = self.GetRasterBand(1).DataType
2636
2637 return _gdal.Dataset_WriteRaster(self,
2638 xoff, yoff, xsize, ysize,
2639 buf_string, buf_xsize, buf_ysize, buf_type, band_list,
2640 buf_pixel_space, buf_line_space, buf_band_space )
2641
2642 - def ReadRaster(self, xoff=0, yoff=0, xsize=None, ysize=None,
2643 buf_xsize=None, buf_ysize=None, buf_type=None,
2644 band_list=None,
2645 buf_pixel_space=None, buf_line_space=None, buf_band_space=None,
2646 resample_alg=gdalconst.GRIORA_NearestNeighbour,
2647 callback=None,
2648 callback_data=None,
2649 buf_obj=None):
2650
2651 if xsize is None:
2652 xsize = self.RasterXSize
2653 if ysize is None:
2654 ysize = self.RasterYSize
2655 if band_list is None:
2656 band_list = list(range(1, self.RasterCount + 1))
2657 if buf_xsize is None:
2658 buf_xsize = xsize
2659 if buf_ysize is None:
2660 buf_ysize = ysize
2661
2662 if buf_type is None:
2663 buf_type = self.GetRasterBand(1).DataType;
2664
2665 return _gdal.Dataset_ReadRaster1(self, xoff, yoff, xsize, ysize,
2666 buf_xsize, buf_ysize, buf_type,
2667 band_list, buf_pixel_space, buf_line_space, buf_band_space,
2668 resample_alg, callback, callback_data, buf_obj )
2669
2670 - def GetVirtualMemArray(self, eAccess=gdalconst.GF_Read, xoff=0, yoff=0,
2671 xsize=None, ysize=None, bufxsize=None, bufysize=None,
2672 datatype=None, band_list=None, band_sequential = True,
2673 cache_size = 10 * 1024 * 1024, page_size_hint = 0,
2674 options=None):
2675 """Return a NumPy array for the dataset, seen as a virtual memory mapping.
2676 If there are several bands and band_sequential = True, an element is
2677 accessed with array[band][y][x].
2678 If there are several bands and band_sequential = False, an element is
2679 accessed with array[y][x][band].
2680 If there is only one band, an element is accessed with array[y][x].
2681 Any reference to the array must be dropped before the last reference to the
2682 related dataset is also dropped.
2683 """
2684 from osgeo import gdal_array
2685 if xsize is None:
2686 xsize = self.RasterXSize
2687 if ysize is None:
2688 ysize = self.RasterYSize
2689 if bufxsize is None:
2690 bufxsize = self.RasterXSize
2691 if bufysize is None:
2692 bufysize = self.RasterYSize
2693 if datatype is None:
2694 datatype = self.GetRasterBand(1).DataType
2695 if band_list is None:
2696 band_list = list(range(1, self.RasterCount + 1))
2697 if options is None:
2698 virtualmem = self.GetVirtualMem(eAccess, xoff, yoff, xsize, ysize, bufxsize, bufysize, datatype, band_list, band_sequential, cache_size, page_size_hint)
2699 else:
2700 virtualmem = self.GetVirtualMem(eAccess, xoff, yoff, xsize, ysize, bufxsize, bufysize, datatype, band_list, band_sequential, cache_size, page_size_hint, options)
2701 return gdal_array.VirtualMemGetArray( virtualmem )
2702
2703 - def GetTiledVirtualMemArray(self, eAccess=gdalconst.GF_Read, xoff=0, yoff=0,
2704 xsize=None, ysize=None, tilexsize=256, tileysize=256,
2705 datatype=None, band_list=None, tile_organization=gdalconst.GTO_BSQ,
2706 cache_size = 10 * 1024 * 1024, options=None):
2707 """Return a NumPy array for the dataset, seen as a virtual memory mapping with
2708 a tile organization.
2709 If there are several bands and tile_organization = gdal.GTO_TIP, an element is
2710 accessed with array[tiley][tilex][y][x][band].
2711 If there are several bands and tile_organization = gdal.GTO_BIT, an element is
2712 accessed with array[tiley][tilex][band][y][x].
2713 If there are several bands and tile_organization = gdal.GTO_BSQ, an element is
2714 accessed with array[band][tiley][tilex][y][x].
2715 If there is only one band, an element is accessed with array[tiley][tilex][y][x].
2716 Any reference to the array must be dropped before the last reference to the
2717 related dataset is also dropped.
2718 """
2719 from osgeo import gdal_array
2720 if xsize is None:
2721 xsize = self.RasterXSize
2722 if ysize is None:
2723 ysize = self.RasterYSize
2724 if datatype is None:
2725 datatype = self.GetRasterBand(1).DataType
2726 if band_list is None:
2727 band_list = list(range(1, self.RasterCount + 1))
2728 if options is None:
2729 virtualmem = self.GetTiledVirtualMem(eAccess,xoff,yoff,xsize,ysize,tilexsize,tileysize,datatype,band_list,tile_organization,cache_size)
2730 else:
2731 virtualmem = self.GetTiledVirtualMem(eAccess,xoff,yoff,xsize,ysize,tilexsize,tileysize,datatype,band_list,tile_organization,cache_size, options)
2732 return gdal_array.VirtualMemGetArray( virtualmem )
2733
2735 sd_list = []
2736
2737 sd = self.GetMetadata('SUBDATASETS')
2738 if sd is None:
2739 return sd_list
2740
2741 i = 1
2742 while 'SUBDATASET_'+str(i)+'_NAME' in sd:
2743 sd_list.append((sd['SUBDATASET_'+str(i)+'_NAME'],
2744 sd['SUBDATASET_'+str(i)+'_DESC']))
2745 i = i + 1
2746 return sd_list
2747
2748 - def BeginAsyncReader(self, xoff, yoff, xsize, ysize, buf_obj=None, buf_xsize=None, buf_ysize=None, buf_type=None, band_list=None, options=None):
2749 if band_list is None:
2750 band_list = list(range(1, self.RasterCount + 1))
2751 if buf_xsize is None:
2752 buf_xsize = 0;
2753 if buf_ysize is None:
2754 buf_ysize = 0;
2755 if buf_type is None:
2756 buf_type = gdalconst.GDT_Byte
2757
2758 if buf_xsize <= 0:
2759 buf_xsize = xsize
2760 if buf_ysize <= 0:
2761 buf_ysize = ysize
2762 options = [] if options is None else options
2763
2764 if buf_obj is None:
2765 from sys import version_info
2766 nRequiredSize = int(buf_xsize * buf_ysize * len(band_list) * (_gdal.GetDataTypeSize(buf_type) / 8))
2767 if version_info >= (3, 0, 0):
2768 buf_obj_ar = [None]
2769 exec("buf_obj_ar[0] = b' ' * nRequiredSize")
2770 buf_obj = buf_obj_ar[0]
2771 else:
2772 buf_obj = ' ' * nRequiredSize
2773 return _gdal.Dataset_BeginAsyncReader(self, xoff, yoff, xsize, ysize, buf_obj, buf_xsize, buf_ysize, buf_type, band_list, 0, 0, 0, options)
2774
2776 """Return the layer given an index or a name"""
2777 if isinstance(iLayer, str):
2778 return self.GetLayerByName(str(iLayer))
2779 elif isinstance(iLayer, int):
2780 return self.GetLayerByIndex(iLayer)
2781 else:
2782 raise TypeError("Input %s is not of String or Int type" % type(iLayer))
2783
2785 """Deletes the layer given an index or layer name"""
2786 if isinstance(value, str):
2787 for i in range(self.GetLayerCount()):
2788 name = self.GetLayer(i).GetName()
2789 if name == value:
2790 return _gdal.Dataset_DeleteLayer(self, i)
2791 raise ValueError("Layer %s not found to delete" % value)
2792 elif isinstance(value, int):
2793 return _gdal.Dataset_DeleteLayer(self, value)
2794 else:
2795 raise TypeError("Input %s is not of String or Int type" % type(value))
2796
2797 - def SetGCPs(self, gcps, wkt_or_spatial_ref):
2798 if isinstance(wkt_or_spatial_ref, str):
2799 return self._SetGCPs(gcps, wkt_or_spatial_ref)
2800 else:
2801 return self._SetGCPs2(gcps, wkt_or_spatial_ref)
2802
2803 Dataset_swigregister = _gdal.Dataset_swigregister
2804 Dataset_swigregister(Dataset)
2805
2806 GEDTST_NONE = _gdal.GEDTST_NONE
2807 GEDTST_JSON = _gdal.GEDTST_JSON
2809 """Proxy of C++ GDALGroupHS class."""
2810
2811 __swig_setmethods__ = {}
2812 __setattr__ = lambda self, name, value: _swig_setattr(self, Group, name, value)
2813 __swig_getmethods__ = {}
2814 __getattr__ = lambda self, name: _swig_getattr(self, Group, name)
2815
2817 raise AttributeError("No constructor defined")
2818 __repr__ = _swig_repr
2819 __swig_destroy__ = _gdal.delete_Group
2820 __del__ = lambda self: None
2821
2823 """GetName(Group self) -> char const *"""
2824 return _gdal.Group_GetName(self, *args)
2825
2826
2828 """GetFullName(Group self) -> char const *"""
2829 return _gdal.Group_GetFullName(self, *args)
2830
2831
2833 """GetMDArrayNames(Group self, char ** options=None) -> char **"""
2834 return _gdal.Group_GetMDArrayNames(self, *args)
2835
2836
2838 """OpenMDArray(Group self, char const * name, char ** options=None) -> MDArray"""
2839 return _gdal.Group_OpenMDArray(self, *args)
2840
2841
2843 """OpenMDArrayFromFullname(Group self, char const * name, char ** options=None) -> MDArray"""
2844 return _gdal.Group_OpenMDArrayFromFullname(self, *args)
2845
2846
2848 """ResolveMDArray(Group self, char const * name, char const * starting_point, char ** options=None) -> MDArray"""
2849 return _gdal.Group_ResolveMDArray(self, *args)
2850
2851
2853 """GetGroupNames(Group self, char ** options=None) -> char **"""
2854 return _gdal.Group_GetGroupNames(self, *args)
2855
2856
2858 """OpenGroup(Group self, char const * name, char ** options=None) -> Group"""
2859 return _gdal.Group_OpenGroup(self, *args)
2860
2861
2863 """OpenGroupFromFullname(Group self, char const * name, char ** options=None) -> Group"""
2864 return _gdal.Group_OpenGroupFromFullname(self, *args)
2865
2866
2868 """GetVectorLayerNames(Group self, char ** options=None) -> char **"""
2869 return _gdal.Group_GetVectorLayerNames(self, *args)
2870
2871
2873 """OpenVectorLayer(Group self, char const * name, char ** options=None) -> Layer"""
2874 return _gdal.Group_OpenVectorLayer(self, *args)
2875
2876
2878 """GetDimensions(Group self, char ** options=None)"""
2879 return _gdal.Group_GetDimensions(self, *args)
2880
2881
2883 """GetAttribute(Group self, char const * name) -> Attribute"""
2884 return _gdal.Group_GetAttribute(self, *args)
2885
2886
2888 """GetAttributes(Group self, char ** options=None)"""
2889 return _gdal.Group_GetAttributes(self, *args)
2890
2891
2893 """GetStructuralInfo(Group self) -> char **"""
2894 return _gdal.Group_GetStructuralInfo(self, *args)
2895
2896
2898 """CreateGroup(Group self, char const * name, char ** options=None) -> Group"""
2899 return _gdal.Group_CreateGroup(self, *args)
2900
2901
2903 """CreateDimension(Group self, char const * name, char const * type, char const * direction, unsigned long long size, char ** options=None) -> Dimension"""
2904 return _gdal.Group_CreateDimension(self, *args)
2905
2906
2908 """CreateMDArray(Group self, char const * name, int nDimensions, ExtendedDataType data_type, char ** options=None) -> MDArray"""
2909 return _gdal.Group_CreateMDArray(self, *args)
2910
2911
2913 """CreateAttribute(Group self, char const * name, int nDimensions, ExtendedDataType data_type, char ** options=None) -> Attribute"""
2914 return _gdal.Group_CreateAttribute(self, *args)
2915
2916 Group_swigregister = _gdal.Group_swigregister
2917 Group_swigregister(Group)
2918
2952 Statistics_swigregister = _gdal.Statistics_swigregister
2953 Statistics_swigregister(Statistics)
2954
2956 """Proxy of C++ GDALMDArrayHS class."""
2957
2958 __swig_setmethods__ = {}
2959 __setattr__ = lambda self, name, value: _swig_setattr(self, MDArray, name, value)
2960 __swig_getmethods__ = {}
2961 __getattr__ = lambda self, name: _swig_getattr(self, MDArray, name)
2962
2964 raise AttributeError("No constructor defined")
2965 __repr__ = _swig_repr
2966 __swig_destroy__ = _gdal.delete_MDArray
2967 __del__ = lambda self: None
2968
2970 """GetName(MDArray self) -> char const *"""
2971 return _gdal.MDArray_GetName(self, *args)
2972
2973
2975 """GetFullName(MDArray self) -> char const *"""
2976 return _gdal.MDArray_GetFullName(self, *args)
2977
2978
2980 """GetTotalElementsCount(MDArray self) -> unsigned long long"""
2981 return _gdal.MDArray_GetTotalElementsCount(self, *args)
2982
2983
2985 """GetDimensionCount(MDArray self) -> size_t"""
2986 return _gdal.MDArray_GetDimensionCount(self, *args)
2987
2988
2990 """GetDimensions(MDArray self)"""
2991 return _gdal.MDArray_GetDimensions(self, *args)
2992
2993
2995 """GetCoordinateVariables(MDArray self)"""
2996 return _gdal.MDArray_GetCoordinateVariables(self, *args)
2997
2998
3000 """GetBlockSize(MDArray self)"""
3001 return _gdal.MDArray_GetBlockSize(self, *args)
3002
3003
3005 """GetProcessingChunkSize(MDArray self, size_t nMaxChunkMemory)"""
3006 return _gdal.MDArray_GetProcessingChunkSize(self, *args)
3007
3008
3010 """GetDataType(MDArray self) -> ExtendedDataType"""
3011 return _gdal.MDArray_GetDataType(self, *args)
3012
3013
3015 """GetStructuralInfo(MDArray self) -> char **"""
3016 return _gdal.MDArray_GetStructuralInfo(self, *args)
3017
3018
3019 - def Read(self, *args):
3020 """Read(MDArray self, int nDims1, int nDims2, int nDims3, int nDims4, ExtendedDataType buffer_datatype) -> CPLErr"""
3021 return _gdal.MDArray_Read(self, *args)
3022
3023
3025 """WriteStringArray(MDArray self, int nDims1, int nDims2, int nDims3, ExtendedDataType buffer_datatype, char ** options) -> CPLErr"""
3026 return _gdal.MDArray_WriteStringArray(self, *args)
3027
3028
3029 - def Write(self, *args):
3030 """Write(MDArray self, int nDims1, int nDims2, int nDims3, int nDims4, ExtendedDataType buffer_datatype, GIntBig buf_len) -> CPLErr"""
3031 return _gdal.MDArray_Write(self, *args)
3032
3033
3035 """AdviseRead(MDArray self, int nDims1, int nDims2, char ** options=None) -> CPLErr"""
3036 return _gdal.MDArray_AdviseRead(self, *args)
3037
3038
3040 """GetAttribute(MDArray self, char const * name) -> Attribute"""
3041 return _gdal.MDArray_GetAttribute(self, *args)
3042
3043
3045 """GetAttributes(MDArray self, char ** options=None)"""
3046 return _gdal.MDArray_GetAttributes(self, *args)
3047
3048
3050 """CreateAttribute(MDArray self, char const * name, int nDimensions, ExtendedDataType data_type, char ** options=None) -> Attribute"""
3051 return _gdal.MDArray_CreateAttribute(self, *args)
3052
3053
3055 """GetNoDataValueAsRaw(MDArray self) -> CPLErr"""
3056 return _gdal.MDArray_GetNoDataValueAsRaw(self, *args)
3057
3058
3060 """GetNoDataValueAsDouble(MDArray self)"""
3061 return _gdal.MDArray_GetNoDataValueAsDouble(self, *args)
3062
3063
3065 """GetNoDataValueAsInt64(MDArray self)"""
3066 return _gdal.MDArray_GetNoDataValueAsInt64(self, *args)
3067
3068
3070 """GetNoDataValueAsUInt64(MDArray self)"""
3071 return _gdal.MDArray_GetNoDataValueAsUInt64(self, *args)
3072
3073
3075 """GetNoDataValueAsString(MDArray self) -> retStringAndCPLFree *"""
3076 return _gdal.MDArray_GetNoDataValueAsString(self, *args)
3077
3078
3080 """SetNoDataValueDouble(MDArray self, double d) -> CPLErr"""
3081 return _gdal.MDArray_SetNoDataValueDouble(self, *args)
3082
3083
3085 """SetNoDataValueInt64(MDArray self, GIntBig v) -> CPLErr"""
3086 return _gdal.MDArray_SetNoDataValueInt64(self, *args)
3087
3088
3090 """SetNoDataValueUInt64(MDArray self, GUIntBig v) -> CPLErr"""
3091 return _gdal.MDArray_SetNoDataValueUInt64(self, *args)
3092
3093
3095 """SetNoDataValueString(MDArray self, char const * nodata) -> CPLErr"""
3096 return _gdal.MDArray_SetNoDataValueString(self, *args)
3097
3098
3100 """SetNoDataValueRaw(MDArray self, GIntBig nLen) -> CPLErr"""
3101 return _gdal.MDArray_SetNoDataValueRaw(self, *args)
3102
3103
3105 """DeleteNoDataValue(MDArray self) -> CPLErr"""
3106 return _gdal.MDArray_DeleteNoDataValue(self, *args)
3107
3108
3110 """GetOffset(MDArray self)"""
3111 return _gdal.MDArray_GetOffset(self, *args)
3112
3113
3115 """GetOffsetStorageType(MDArray self) -> GDALDataType"""
3116 return _gdal.MDArray_GetOffsetStorageType(self, *args)
3117
3118
3120 """GetScale(MDArray self)"""
3121 return _gdal.MDArray_GetScale(self, *args)
3122
3123
3125 """GetScaleStorageType(MDArray self) -> GDALDataType"""
3126 return _gdal.MDArray_GetScaleStorageType(self, *args)
3127
3128
3130 """SetOffset(MDArray self, double val, GDALDataType storageType) -> CPLErr"""
3131 return _gdal.MDArray_SetOffset(self, *args, **kwargs)
3132
3133
3135 """SetScale(MDArray self, double val, GDALDataType storageType) -> CPLErr"""
3136 return _gdal.MDArray_SetScale(self, *args, **kwargs)
3137
3138
3140 """SetUnit(MDArray self, char const * unit) -> CPLErr"""
3141 return _gdal.MDArray_SetUnit(self, *args)
3142
3143
3145 """GetUnit(MDArray self) -> char const *"""
3146 return _gdal.MDArray_GetUnit(self, *args)
3147
3148
3150 """SetSpatialRef(MDArray self, SpatialReference srs) -> OGRErr"""
3151 return _gdal.MDArray_SetSpatialRef(self, *args)
3152
3153
3155 """GetSpatialRef(MDArray self) -> SpatialReference"""
3156 return _gdal.MDArray_GetSpatialRef(self, *args)
3157
3158
3160 """GetView(MDArray self, char const * viewExpr) -> MDArray"""
3161 return _gdal.MDArray_GetView(self, *args)
3162
3163
3165 """Transpose(MDArray self, int nList) -> MDArray"""
3166 return _gdal.MDArray_Transpose(self, *args)
3167
3168
3170 """GetUnscaled(MDArray self) -> MDArray"""
3171 return _gdal.MDArray_GetUnscaled(self, *args)
3172
3173
3175 """GetMask(MDArray self, char ** options=None) -> MDArray"""
3176 return _gdal.MDArray_GetMask(self, *args)
3177
3178
3180 """AsClassicDataset(MDArray self, size_t iXDim, size_t iYDim) -> Dataset"""
3181 return _gdal.MDArray_AsClassicDataset(self, *args)
3182
3183
3185 """GetStatistics(MDArray self, bool approx_ok=False, bool force=True, GDALProgressFunc callback=0, void * callback_data=None) -> Statistics"""
3186 return _gdal.MDArray_GetStatistics(self, *args, **kwargs)
3187
3188
3190 """ComputeStatistics(MDArray self, bool approx_ok=False, GDALProgressFunc callback=0, void * callback_data=None) -> Statistics"""
3191 return _gdal.MDArray_ComputeStatistics(self, *args, **kwargs)
3192
3193
3195 """GetResampled(MDArray self, int nDimensions, GDALRIOResampleAlg resample_alg, OSRSpatialReferenceShadow ** srs, char ** options=None) -> MDArray"""
3196 return _gdal.MDArray_GetResampled(self, *args)
3197
3198
3199 - def Cache(self, *args):
3200 """Cache(MDArray self, char ** options=None) -> bool"""
3201 return _gdal.MDArray_Cache(self, *args)
3202
3203
3204 - def Read(self,
3205 array_start_idx = None,
3206 count = None,
3207 array_step = None,
3208 buffer_stride = None,
3209 buffer_datatype = None):
3210 if not array_start_idx:
3211 array_start_idx = [0] * self.GetDimensionCount()
3212 if not count:
3213 count = [ dim.GetSize() for dim in self.GetDimensions() ]
3214 if not array_step:
3215 array_step = [1] * self.GetDimensionCount()
3216 if not buffer_stride:
3217 stride = 1
3218 buffer_stride = []
3219
3220
3221 for cnt in reversed(count):
3222 buffer_stride.append(stride)
3223 stride *= cnt
3224 buffer_stride.reverse()
3225 if not buffer_datatype:
3226 buffer_datatype = self.GetDataType()
3227 return _gdal.MDArray_Read(self, array_start_idx, count, array_step, buffer_stride, buffer_datatype)
3228
3229 - def ReadAsArray(self,
3230 array_start_idx = None,
3231 count = None,
3232 array_step = None,
3233 buffer_datatype = None,
3234 buf_obj = None):
3238
3239 - def AdviseRead(self, array_start_idx = None, count = None, options = []):
3245
3247
3248 def stringify(v):
3249 if v == Ellipsis:
3250 return '...'
3251 if isinstance(v, slice):
3252 return ':'.join([str(x) if x is not None else '' for x in (v.start, v.stop, v.step)])
3253 if isinstance(v, str):
3254 return v
3255 if isinstance(v, (int, type(12345678901234))):
3256 return str(v)
3257 try:
3258 import numpy as np
3259 if v == np.newaxis:
3260 return 'newaxis'
3261 except:
3262 pass
3263
3264 return str(v)
3265
3266 if isinstance(item, str):
3267 return self.GetView('["' + item.replace('\\', '\\\\').replace('"', '\\"') + '"]')
3268 elif isinstance(item, slice):
3269 return self.GetView('[' + stringify(item) + ']')
3270 elif isinstance(item, tuple):
3271 return self.GetView('[' + ','.join([stringify(x) for x in item]) + ']')
3272 else:
3273 return self.GetView('[' + stringify(item) + ']')
3274
3275 - def Write(self,
3276 buffer,
3277 array_start_idx = None,
3278 count = None,
3279 array_step = None,
3280 buffer_stride = None,
3281 buffer_datatype = None):
3282
3283 dimCount = self.GetDimensionCount()
3284
3285
3286
3287 if type(buffer).__name__ == 'ndarray' and \
3288 count is None and buffer_stride is None and buffer_datatype is None:
3289 return self.WriteArray(buffer, array_start_idx=array_start_idx, array_step=array_step)
3290
3291
3292 if dimCount == 1 and type(buffer).__name__ == 'array' and \
3293 count is None and buffer_stride is None and buffer_datatype is None:
3294 map_typecode_itemsize_to_gdal = {
3295 ('B',1): GDT_Byte,
3296 ('h',2): GDT_Int16,
3297 ('H',2): GDT_UInt16,
3298 ('i',4): GDT_Int32,
3299 ('I',4): GDT_UInt32,
3300 ('l',4): GDT_Int32,
3301
3302
3303
3304 ('f', 4): GDT_Float32,
3305 ('d', 8): GDT_Float64
3306 }
3307 key = (buffer.typecode, buffer.itemsize)
3308 if key not in map_typecode_itemsize_to_gdal:
3309 raise Exception("unhandled type for buffer of type array")
3310 buffer_datatype = ExtendedDataType.Create(map_typecode_itemsize_to_gdal[key])
3311
3312
3313 elif dimCount == 1 and type(buffer) == type([]) and len(buffer) != 0 \
3314 and self.GetDataType().GetClass() != GEDTC_STRING:
3315 buffer_datatype = GDT_Int32
3316 for v in buffer:
3317 if isinstance(v, int):
3318 if v >= (1 << 31) or v < -(1 << 31):
3319 buffer_datatype = GDT_Float64
3320 elif isinstance(v, float):
3321 buffer_datatype = GDT_Float64
3322 else:
3323 raise ValueError('Only lists with integer or float elements are supported')
3324 import array
3325 buffer = array.array('d' if buffer_datatype == GDT_Float64 else 'i', buffer)
3326 buffer_datatype = ExtendedDataType.Create(buffer_datatype)
3327
3328 if not buffer_datatype:
3329 buffer_datatype = self.GetDataType()
3330
3331 is_1d_string = self.GetDataType().GetClass() == GEDTC_STRING and buffer_datatype.GetClass() == GEDTC_STRING and dimCount == 1
3332
3333 if not array_start_idx:
3334 array_start_idx = [0] * dimCount
3335
3336 if not count:
3337 if is_1d_string:
3338 assert type(buffer) == type([])
3339 count = [ len(buffer) ]
3340 else:
3341 count = [ dim.GetSize() for dim in self.GetDimensions() ]
3342
3343 if not array_step:
3344 array_step = [1] * dimCount
3345
3346 if not buffer_stride:
3347 stride = 1
3348 buffer_stride = []
3349
3350
3351 for cnt in reversed(count):
3352 buffer_stride.append(stride)
3353 stride *= cnt
3354 buffer_stride.reverse()
3355
3356 if is_1d_string:
3357 return _gdal.MDArray_WriteStringArray(self, array_start_idx, count, array_step, buffer_datatype, buffer)
3358
3359 return _gdal.MDArray_Write(self, array_start_idx, count, array_step, buffer_stride, buffer_datatype, buffer)
3360
3361 - def WriteArray(self, array,
3362 array_start_idx = None,
3363 array_step = None):
3367
3368 - def ReadAsMaskedArray(self,
3369 array_start_idx = None,
3370 count = None,
3371 array_step = None):
3372 """ Return a numpy masked array of ReadAsArray() with GetMask() """
3373 import numpy
3374 mask = self.GetMask()
3375 if mask is not None:
3376 array = self.ReadAsArray(array_start_idx, count, array_step)
3377 mask_array = mask.ReadAsArray(array_start_idx, count, array_step)
3378 bool_array = ~mask_array.astype(bool)
3379 return numpy.ma.array(array, mask=bool_array)
3380 else:
3381 return numpy.ma.array(self.ReadAsArray(array_start_idx, count, array_step), mask=None)
3382
3384 """ Return the shape of the array """
3385 if not self.GetDimensionCount():
3386 return None
3387 shp = ()
3388 for dim in self.GetDimensions():
3389 shp += (dim.GetSize(),)
3390 return shp
3391
3392 shape = property(fget=GetShape, doc='Returns the shape of the array.')
3393
3405
3406
3418
3419
3420 MDArray_swigregister = _gdal.MDArray_swigregister
3421 MDArray_swigregister(MDArray)
3422
3424 """Proxy of C++ GDALAttributeHS class."""
3425
3426 __swig_setmethods__ = {}
3427 __setattr__ = lambda self, name, value: _swig_setattr(self, Attribute, name, value)
3428 __swig_getmethods__ = {}
3429 __getattr__ = lambda self, name: _swig_getattr(self, Attribute, name)
3430
3432 raise AttributeError("No constructor defined")
3433 __repr__ = _swig_repr
3434 __swig_destroy__ = _gdal.delete_Attribute
3435 __del__ = lambda self: None
3436
3438 """GetName(Attribute self) -> char const *"""
3439 return _gdal.Attribute_GetName(self, *args)
3440
3441
3443 """GetFullName(Attribute self) -> char const *"""
3444 return _gdal.Attribute_GetFullName(self, *args)
3445
3446
3448 """GetTotalElementsCount(Attribute self) -> unsigned long long"""
3449 return _gdal.Attribute_GetTotalElementsCount(self, *args)
3450
3451
3453 """GetDimensionCount(Attribute self) -> size_t"""
3454 return _gdal.Attribute_GetDimensionCount(self, *args)
3455
3456
3458 """GetDimensionsSize(Attribute self)"""
3459 return _gdal.Attribute_GetDimensionsSize(self, *args)
3460
3461
3463 """GetDataType(Attribute self) -> ExtendedDataType"""
3464 return _gdal.Attribute_GetDataType(self, *args)
3465
3466
3468 """ReadAsRaw(Attribute self) -> CPLErr"""
3469 return _gdal.Attribute_ReadAsRaw(self, *args)
3470
3471
3473 """ReadAsString(Attribute self) -> char const *"""
3474 return _gdal.Attribute_ReadAsString(self, *args)
3475
3476
3478 """ReadAsInt(Attribute self) -> int"""
3479 return _gdal.Attribute_ReadAsInt(self, *args)
3480
3481
3483 """ReadAsDouble(Attribute self) -> double"""
3484 return _gdal.Attribute_ReadAsDouble(self, *args)
3485
3486
3488 """ReadAsStringArray(Attribute self) -> char **"""
3489 return _gdal.Attribute_ReadAsStringArray(self, *args)
3490
3491
3493 """ReadAsIntArray(Attribute self)"""
3494 return _gdal.Attribute_ReadAsIntArray(self, *args)
3495
3496
3498 """ReadAsDoubleArray(Attribute self)"""
3499 return _gdal.Attribute_ReadAsDoubleArray(self, *args)
3500
3501
3503 """WriteRaw(Attribute self, GIntBig nLen) -> CPLErr"""
3504 return _gdal.Attribute_WriteRaw(self, *args)
3505
3506
3508 """WriteString(Attribute self, char const * val) -> CPLErr"""
3509 return _gdal.Attribute_WriteString(self, *args)
3510
3511
3513 """WriteStringArray(Attribute self, char ** vals) -> CPLErr"""
3514 return _gdal.Attribute_WriteStringArray(self, *args)
3515
3516
3518 """WriteInt(Attribute self, int val) -> CPLErr"""
3519 return _gdal.Attribute_WriteInt(self, *args)
3520
3521
3523 """WriteDouble(Attribute self, double val) -> CPLErr"""
3524 return _gdal.Attribute_WriteDouble(self, *args)
3525
3526
3528 """WriteDoubleArray(Attribute self, int nList) -> CPLErr"""
3529 return _gdal.Attribute_WriteDoubleArray(self, *args)
3530
3531
3532
3560
3562 if isinstance(val, (int, type(12345678901234))):
3563 if val >= -0x80000000 and val <= 0x7FFFFFFF:
3564 return self.WriteInt(val)
3565 else:
3566 return self.WriteDouble(val)
3567 if isinstance(val, float):
3568 return self.WriteDouble(val)
3569 if isinstance(val, str) and self.GetDataType().GetClass() != GEDTC_COMPOUND:
3570 return self.WriteString(val)
3571 if isinstance(val, list):
3572 if len(val) == 0:
3573 if self.GetDataType().GetClass() == GEDTC_STRING:
3574 return self.WriteStringArray(val)
3575 else:
3576 return self.WriteDoubleArray(val)
3577 if isinstance(val[0], (int, type(12345678901234), float)):
3578 return self.WriteDoubleArray(val)
3579 if isinstance(val[0], str):
3580 return self.WriteStringArray(val)
3581 if isinstance(val, dict) and self.GetDataType().GetSubType() == GEDTST_JSON:
3582 import json
3583 return self.WriteString(json.dumps(val))
3584 return self.WriteRaw(val)
3585
3586
3587 Attribute_swigregister = _gdal.Attribute_swigregister
3588 Attribute_swigregister(Attribute)
3589
3591 """Proxy of C++ GDALDimensionHS class."""
3592
3593 __swig_setmethods__ = {}
3594 __setattr__ = lambda self, name, value: _swig_setattr(self, Dimension, name, value)
3595 __swig_getmethods__ = {}
3596 __getattr__ = lambda self, name: _swig_getattr(self, Dimension, name)
3597
3599 raise AttributeError("No constructor defined")
3600 __repr__ = _swig_repr
3601 __swig_destroy__ = _gdal.delete_Dimension
3602 __del__ = lambda self: None
3603
3605 """GetName(Dimension self) -> char const *"""
3606 return _gdal.Dimension_GetName(self, *args)
3607
3608
3610 """GetFullName(Dimension self) -> char const *"""
3611 return _gdal.Dimension_GetFullName(self, *args)
3612
3613
3615 """GetType(Dimension self) -> char const *"""
3616 return _gdal.Dimension_GetType(self, *args)
3617
3618
3620 """GetDirection(Dimension self) -> char const *"""
3621 return _gdal.Dimension_GetDirection(self, *args)
3622
3623
3625 """GetSize(Dimension self) -> unsigned long long"""
3626 return _gdal.Dimension_GetSize(self, *args)
3627
3628
3630 """GetIndexingVariable(Dimension self) -> MDArray"""
3631 return _gdal.Dimension_GetIndexingVariable(self, *args)
3632
3633
3635 """SetIndexingVariable(Dimension self, MDArray array) -> bool"""
3636 return _gdal.Dimension_SetIndexingVariable(self, *args)
3637
3638 Dimension_swigregister = _gdal.Dimension_swigregister
3639 Dimension_swigregister(Dimension)
3640
3641 GEDTC_NUMERIC = _gdal.GEDTC_NUMERIC
3642 GEDTC_STRING = _gdal.GEDTC_STRING
3643 GEDTC_COMPOUND = _gdal.GEDTC_COMPOUND
3645 """Proxy of C++ GDALExtendedDataTypeHS class."""
3646
3647 __swig_setmethods__ = {}
3648 __setattr__ = lambda self, name, value: _swig_setattr(self, ExtendedDataType, name, value)
3649 __swig_getmethods__ = {}
3650 __getattr__ = lambda self, name: _swig_getattr(self, ExtendedDataType, name)
3651
3653 raise AttributeError("No constructor defined")
3654 __repr__ = _swig_repr
3655 __swig_destroy__ = _gdal.delete_ExtendedDataType
3656 __del__ = lambda self: None
3657
3661
3662 Create = staticmethod(Create)
3663
3665 """CreateString(size_t nMaxStringLength=0, GDALExtendedDataTypeSubType eSubType=GEDTST_NONE) -> ExtendedDataType"""
3666 return _gdal.ExtendedDataType_CreateString(*args)
3667
3668 CreateString = staticmethod(CreateString)
3669
3673
3674 CreateCompound = staticmethod(CreateCompound)
3675
3677 """GetName(ExtendedDataType self) -> char const *"""
3678 return _gdal.ExtendedDataType_GetName(self, *args)
3679
3680
3682 """GetClass(ExtendedDataType self) -> GDALExtendedDataTypeClass"""
3683 return _gdal.ExtendedDataType_GetClass(self, *args)
3684
3685
3687 """GetNumericDataType(ExtendedDataType self) -> GDALDataType"""
3688 return _gdal.ExtendedDataType_GetNumericDataType(self, *args)
3689
3690
3692 """GetSize(ExtendedDataType self) -> size_t"""
3693 return _gdal.ExtendedDataType_GetSize(self, *args)
3694
3695
3697 """GetMaxStringLength(ExtendedDataType self) -> size_t"""
3698 return _gdal.ExtendedDataType_GetMaxStringLength(self, *args)
3699
3700
3702 """GetSubType(ExtendedDataType self) -> GDALExtendedDataTypeSubType"""
3703 return _gdal.ExtendedDataType_GetSubType(self, *args)
3704
3705
3707 """GetComponents(ExtendedDataType self)"""
3708 return _gdal.ExtendedDataType_GetComponents(self, *args)
3709
3710
3712 """CanConvertTo(ExtendedDataType self, ExtendedDataType other) -> bool"""
3713 return _gdal.ExtendedDataType_CanConvertTo(self, *args)
3714
3715
3717 """Equals(ExtendedDataType self, ExtendedDataType other) -> bool"""
3718 return _gdal.ExtendedDataType_Equals(self, *args)
3719
3720
3721
3723 return self.Equals(other)
3724
3726 return not self.__eq__(other)
3727
3728 ExtendedDataType_swigregister = _gdal.ExtendedDataType_swigregister
3729 ExtendedDataType_swigregister(ExtendedDataType)
3730
3734
3736 """ExtendedDataType_CreateString(size_t nMaxStringLength=0, GDALExtendedDataTypeSubType eSubType=GEDTST_NONE) -> ExtendedDataType"""
3737 return _gdal.ExtendedDataType_CreateString(*args)
3738
3742
3744 """Proxy of C++ GDALEDTComponentHS class."""
3745
3746 __swig_setmethods__ = {}
3747 __setattr__ = lambda self, name, value: _swig_setattr(self, EDTComponent, name, value)
3748 __swig_getmethods__ = {}
3749 __getattr__ = lambda self, name: _swig_getattr(self, EDTComponent, name)
3750
3752 raise AttributeError("No constructor defined")
3753 __repr__ = _swig_repr
3754 __swig_destroy__ = _gdal.delete_EDTComponent
3755 __del__ = lambda self: None
3756
3758 """Create(char const * name, size_t offset, ExtendedDataType type) -> EDTComponent"""
3759 return _gdal.EDTComponent_Create(*args)
3760
3761 Create = staticmethod(Create)
3762
3764 """GetName(EDTComponent self) -> char const *"""
3765 return _gdal.EDTComponent_GetName(self, *args)
3766
3767
3769 """GetOffset(EDTComponent self) -> size_t"""
3770 return _gdal.EDTComponent_GetOffset(self, *args)
3771
3772
3774 """GetType(EDTComponent self) -> ExtendedDataType"""
3775 return _gdal.EDTComponent_GetType(self, *args)
3776
3777 EDTComponent_swigregister = _gdal.EDTComponent_swigregister
3778 EDTComponent_swigregister(EDTComponent)
3779
3781 """EDTComponent_Create(char const * name, size_t offset, ExtendedDataType type) -> EDTComponent"""
3782 return _gdal.EDTComponent_Create(*args)
3783
3784 -class Band(MajorObject):
3785 """Proxy of C++ GDALRasterBandShadow class."""
3786
3787 __swig_setmethods__ = {}
3788 for _s in [MajorObject]:
3789 __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
3790 __setattr__ = lambda self, name, value: _swig_setattr(self, Band, name, value)
3791 __swig_getmethods__ = {}
3792 for _s in [MajorObject]:
3793 __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
3794 __getattr__ = lambda self, name: _swig_getattr(self, Band, name)
3795
3797 raise AttributeError("No constructor defined")
3798 __repr__ = _swig_repr
3799 __swig_getmethods__["XSize"] = _gdal.Band_XSize_get
3800 if _newclass:
3801 XSize = _swig_property(_gdal.Band_XSize_get)
3802 __swig_getmethods__["YSize"] = _gdal.Band_YSize_get
3803 if _newclass:
3804 YSize = _swig_property(_gdal.Band_YSize_get)
3805 __swig_getmethods__["DataType"] = _gdal.Band_DataType_get
3806 if _newclass:
3807 DataType = _swig_property(_gdal.Band_DataType_get)
3808
3810 """GetDataset(Band self) -> Dataset"""
3811 return _gdal.Band_GetDataset(self, *args)
3812
3813
3815 """GetBand(Band self) -> int"""
3816 return _gdal.Band_GetBand(self, *args)
3817
3818
3820 """GetBlockSize(Band self)"""
3821 return _gdal.Band_GetBlockSize(self, *args)
3822
3823
3825 """GetActualBlockSize(Band self, int nXBlockOff, int nYBlockOff)"""
3826 return _gdal.Band_GetActualBlockSize(self, *args)
3827
3828
3830 """GetColorInterpretation(Band self) -> GDALColorInterp"""
3831 return _gdal.Band_GetColorInterpretation(self, *args)
3832
3833
3835 """GetRasterColorInterpretation(Band self) -> GDALColorInterp"""
3836 return _gdal.Band_GetRasterColorInterpretation(self, *args)
3837
3838
3840 """SetColorInterpretation(Band self, GDALColorInterp val) -> CPLErr"""
3841 return _gdal.Band_SetColorInterpretation(self, *args)
3842
3843
3845 """SetRasterColorInterpretation(Band self, GDALColorInterp val) -> CPLErr"""
3846 return _gdal.Band_SetRasterColorInterpretation(self, *args)
3847
3848
3850 """GetNoDataValue(Band self)"""
3851 return _gdal.Band_GetNoDataValue(self, *args)
3852
3853
3855 """GetNoDataValueAsInt64(Band self)"""
3856 return _gdal.Band_GetNoDataValueAsInt64(self, *args)
3857
3858
3860 """GetNoDataValueAsUInt64(Band self)"""
3861 return _gdal.Band_GetNoDataValueAsUInt64(self, *args)
3862
3863
3865 """SetNoDataValue(Band self, double d) -> CPLErr"""
3866 return _gdal.Band_SetNoDataValue(self, *args)
3867
3868
3870 """SetNoDataValueAsInt64(Band self, GIntBig v) -> CPLErr"""
3871 return _gdal.Band_SetNoDataValueAsInt64(self, *args)
3872
3873
3875 """SetNoDataValueAsUInt64(Band self, GUIntBig v) -> CPLErr"""
3876 return _gdal.Band_SetNoDataValueAsUInt64(self, *args)
3877
3878
3880 """DeleteNoDataValue(Band self) -> CPLErr"""
3881 return _gdal.Band_DeleteNoDataValue(self, *args)
3882
3883
3885 """GetUnitType(Band self) -> char const *"""
3886 return _gdal.Band_GetUnitType(self, *args)
3887
3888
3890 """SetUnitType(Band self, char const * val) -> CPLErr"""
3891 return _gdal.Band_SetUnitType(self, *args)
3892
3893
3895 """GetRasterCategoryNames(Band self) -> char **"""
3896 return _gdal.Band_GetRasterCategoryNames(self, *args)
3897
3898
3900 """SetRasterCategoryNames(Band self, char ** names) -> CPLErr"""
3901 return _gdal.Band_SetRasterCategoryNames(self, *args)
3902
3903
3905 """GetMinimum(Band self)"""
3906 return _gdal.Band_GetMinimum(self, *args)
3907
3908
3910 """GetMaximum(Band self)"""
3911 return _gdal.Band_GetMaximum(self, *args)
3912
3913
3915 """GetOffset(Band self)"""
3916 return _gdal.Band_GetOffset(self, *args)
3917
3918
3920 """GetScale(Band self)"""
3921 return _gdal.Band_GetScale(self, *args)
3922
3923
3925 """SetOffset(Band self, double val) -> CPLErr"""
3926 return _gdal.Band_SetOffset(self, *args)
3927
3928
3930 """SetScale(Band self, double val) -> CPLErr"""
3931 return _gdal.Band_SetScale(self, *args)
3932
3933
3935 """GetStatistics(Band self, int approx_ok, int force) -> CPLErr"""
3936 return _gdal.Band_GetStatistics(self, *args)
3937
3938
3940 """ComputeStatistics(Band self, bool approx_ok, GDALProgressFunc callback=0, void * callback_data=None) -> CPLErr"""
3941 return _gdal.Band_ComputeStatistics(self, *args)
3942
3943
3945 """SetStatistics(Band self, double min, double max, double mean, double stddev) -> CPLErr"""
3946 return _gdal.Band_SetStatistics(self, *args)
3947
3948
3950 """GetOverviewCount(Band self) -> int"""
3951 return _gdal.Band_GetOverviewCount(self, *args)
3952
3953
3955 """GetOverview(Band self, int i) -> Band"""
3956 return _gdal.Band_GetOverview(self, *args)
3957
3958
3960 """Checksum(Band self, int xoff=0, int yoff=0, int * xsize=None, int * ysize=None) -> int"""
3961 return _gdal.Band_Checksum(self, *args, **kwargs)
3962
3963
3965 """ComputeRasterMinMax(Band self, int approx_ok=0)"""
3966 return _gdal.Band_ComputeRasterMinMax(self, *args)
3967
3968
3970 """ComputeBandStats(Band self, int samplestep=1)"""
3971 return _gdal.Band_ComputeBandStats(self, *args)
3972
3973
3974 - def Fill(self, *args):
3975 """Fill(Band self, double real_fill, double imag_fill=0.0) -> CPLErr"""
3976 return _gdal.Band_Fill(self, *args)
3977
3978
3980 """WriteRaster(Band self, int xoff, int yoff, int xsize, int ysize, GIntBig buf_len, int * buf_xsize=None, int * buf_ysize=None, GDALDataType * buf_type=None, GIntBig * buf_pixel_space=None, GIntBig * buf_line_space=None) -> CPLErr"""
3981 return _gdal.Band_WriteRaster(self, *args, **kwargs)
3982
3983
3985 """FlushCache(Band self)"""
3986 return _gdal.Band_FlushCache(self, *args)
3987
3988
3990 """GetRasterColorTable(Band self) -> ColorTable"""
3991 return _gdal.Band_GetRasterColorTable(self, *args)
3992
3993
3995 """GetColorTable(Band self) -> ColorTable"""
3996 return _gdal.Band_GetColorTable(self, *args)
3997
3998
4000 """SetRasterColorTable(Band self, ColorTable arg) -> int"""
4001 return _gdal.Band_SetRasterColorTable(self, *args)
4002
4003
4005 """SetColorTable(Band self, ColorTable arg) -> int"""
4006 return _gdal.Band_SetColorTable(self, *args)
4007
4008
4010 """GetDefaultRAT(Band self) -> RasterAttributeTable"""
4011 return _gdal.Band_GetDefaultRAT(self, *args)
4012
4013
4015 """SetDefaultRAT(Band self, RasterAttributeTable table) -> int"""
4016 return _gdal.Band_SetDefaultRAT(self, *args)
4017
4018
4020 """GetMaskBand(Band self) -> Band"""
4021 return _gdal.Band_GetMaskBand(self, *args)
4022
4023
4025 """GetMaskFlags(Band self) -> int"""
4026 return _gdal.Band_GetMaskFlags(self, *args)
4027
4028
4030 """CreateMaskBand(Band self, int nFlags) -> CPLErr"""
4031 return _gdal.Band_CreateMaskBand(self, *args)
4032
4033
4035 """IsMaskBand(Band self) -> bool"""
4036 return _gdal.Band_IsMaskBand(self, *args)
4037
4038
4040 """GetHistogram(Band self, double min=-0.5, double max=255.5, int buckets=256, int include_out_of_range=0, int approx_ok=1, GDALProgressFunc callback=0, void * callback_data=None) -> CPLErr"""
4041 return _gdal.Band_GetHistogram(self, *args, **kwargs)
4042
4043
4045 """GetDefaultHistogram(Band self, double * min_ret=None, double * max_ret=None, int * buckets_ret=None, GUIntBig ** ppanHistogram=None, int force=1, GDALProgressFunc callback=0, void * callback_data=None) -> CPLErr"""
4046 return _gdal.Band_GetDefaultHistogram(self, *args, **kwargs)
4047
4048
4050 """SetDefaultHistogram(Band self, double min, double max, int buckets_in) -> CPLErr"""
4051 return _gdal.Band_SetDefaultHistogram(self, *args)
4052
4053
4055 """HasArbitraryOverviews(Band self) -> bool"""
4056 return _gdal.Band_HasArbitraryOverviews(self, *args)
4057
4058
4060 """GetCategoryNames(Band self) -> char **"""
4061 return _gdal.Band_GetCategoryNames(self, *args)
4062
4063
4065 """SetCategoryNames(Band self, char ** papszCategoryNames) -> CPLErr"""
4066 return _gdal.Band_SetCategoryNames(self, *args)
4067
4068
4070 """GetVirtualMem(Band self, GDALRWFlag eRWFlag, int nXOff, int nYOff, int nXSize, int nYSize, int nBufXSize, int nBufYSize, GDALDataType eBufType, size_t nCacheSize, size_t nPageSizeHint, char ** options=None) -> VirtualMem"""
4071 return _gdal.Band_GetVirtualMem(self, *args, **kwargs)
4072
4073
4075 """GetVirtualMemAuto(Band self, GDALRWFlag eRWFlag, char ** options=None) -> VirtualMem"""
4076 return _gdal.Band_GetVirtualMemAuto(self, *args, **kwargs)
4077
4078
4080 """GetTiledVirtualMem(Band self, GDALRWFlag eRWFlag, int nXOff, int nYOff, int nXSize, int nYSize, int nTileXSize, int nTileYSize, GDALDataType eBufType, size_t nCacheSize, char ** options=None) -> VirtualMem"""
4081 return _gdal.Band_GetTiledVirtualMem(self, *args, **kwargs)
4082
4083
4085 """GetDataCoverageStatus(Band self, int nXOff, int nYOff, int nXSize, int nYSize, int nMaskFlagStop=0) -> int"""
4086 return _gdal.Band_GetDataCoverageStatus(self, *args)
4087
4088
4090 """AdviseRead(Band self, int xoff, int yoff, int xsize, int ysize, int * buf_xsize=None, int * buf_ysize=None, GDALDataType * buf_type=None, char ** options=None) -> CPLErr"""
4091 return _gdal.Band_AdviseRead(self, *args)
4092
4093
4095 """AsMDArray(Band self) -> MDArray"""
4096 return _gdal.Band_AsMDArray(self, *args)
4097
4098
4100 """ReadRaster1(Band self, double xoff, double yoff, double xsize, double ysize, int * buf_xsize=None, int * buf_ysize=None, GDALDataType * buf_type=None, GIntBig * buf_pixel_space=None, GIntBig * buf_line_space=None, GDALRIOResampleAlg resample_alg, GDALProgressFunc callback=0, void * callback_data=None, void * inputOutputBuf=None) -> CPLErr"""
4101 return _gdal.Band_ReadRaster1(self, *args, **kwargs)
4102
4103
4105 """ReadBlock(Band self, int xoff, int yoff, void * buf_obj=None) -> CPLErr"""
4106 return _gdal.Band_ReadBlock(self, *args, **kwargs)
4107
4108
4109
4111 """ComputeStatistics(Band self, bool approx_ok, GDALProgressFunc callback=0, void * callback_data=None) -> CPLErr"""
4112
4113
4114
4115 approx_ok = args[0]
4116 if approx_ok == 0:
4117 approx_ok = False
4118 elif approx_ok == 1:
4119 approx_ok = True
4120 new_args = [approx_ok]
4121 for arg in args[1:]:
4122 new_args.append( arg )
4123
4124 return _gdal.Band_ComputeStatistics(self, *new_args)
4125
4126
4127 - def ReadRaster(self, xoff=0, yoff=0, xsize=None, ysize=None,
4128 buf_xsize=None, buf_ysize=None, buf_type=None,
4129 buf_pixel_space=None, buf_line_space=None,
4130 resample_alg=gdalconst.GRIORA_NearestNeighbour,
4131 callback=None,
4132 callback_data=None,
4133 buf_obj=None):
4134
4135 if xsize is None:
4136 xsize = self.XSize
4137 if ysize is None:
4138 ysize = self.YSize
4139
4140 return _gdal.Band_ReadRaster1(self, xoff, yoff, xsize, ysize,
4141 buf_xsize, buf_ysize, buf_type,
4142 buf_pixel_space, buf_line_space,
4143 resample_alg, callback, callback_data,
4144 buf_obj)
4145
4146 - def WriteRaster(self, xoff, yoff, xsize, ysize,
4147 buf_string,
4148 buf_xsize=None, buf_ysize=None, buf_type=None,
4149 buf_pixel_space=None, buf_line_space=None ):
4150
4151 if buf_xsize is None:
4152 buf_xsize = xsize
4153 if buf_ysize is None:
4154 buf_ysize = ysize
4155
4156
4157
4158 if type(buf_string).__name__ == 'ndarray' and \
4159 buf_xsize == xsize and buf_ysize == ysize and buf_type is None and \
4160 buf_pixel_space is None and buf_line_space is None:
4161 return self.WriteArray(buf_string, xoff=xoff, yoff=yoff)
4162
4163 if buf_type is None:
4164 buf_type = self.DataType
4165
4166 return _gdal.Band_WriteRaster(self,
4167 xoff, yoff, xsize, ysize,
4168 buf_string, buf_xsize, buf_ysize, buf_type,
4169 buf_pixel_space, buf_line_space )
4170
4171 - def ReadAsArray(self, xoff=0, yoff=0, win_xsize=None, win_ysize=None,
4172 buf_xsize=None, buf_ysize=None, buf_type=None, buf_obj=None,
4173 resample_alg=gdalconst.GRIORA_NearestNeighbour,
4174 callback=None,
4175 callback_data=None):
4176 """ Reading a chunk of a GDAL band into a numpy array. The optional (buf_xsize,buf_ysize,buf_type)
4177 parameters should generally not be specified if buf_obj is specified. The array is returned"""
4178
4179 from osgeo import gdal_array
4180
4181 return gdal_array.BandReadAsArray(self, xoff, yoff,
4182 win_xsize, win_ysize,
4183 buf_xsize, buf_ysize, buf_type, buf_obj,
4184 resample_alg=resample_alg,
4185 callback=callback,
4186 callback_data=callback_data)
4187
4198
4199 - def GetVirtualMemArray(self, eAccess=gdalconst.GF_Read, xoff=0, yoff=0,
4200 xsize=None, ysize=None, bufxsize=None, bufysize=None,
4201 datatype=None,
4202 cache_size = 10 * 1024 * 1024, page_size_hint = 0,
4203 options=None):
4204 """Return a NumPy array for the band, seen as a virtual memory mapping.
4205 An element is accessed with array[y][x].
4206 Any reference to the array must be dropped before the last reference to the
4207 related dataset is also dropped.
4208 """
4209 from osgeo import gdal_array
4210 if xsize is None:
4211 xsize = self.XSize
4212 if ysize is None:
4213 ysize = self.YSize
4214 if bufxsize is None:
4215 bufxsize = self.XSize
4216 if bufysize is None:
4217 bufysize = self.YSize
4218 if datatype is None:
4219 datatype = self.DataType
4220 if options is None:
4221 virtualmem = self.GetVirtualMem(eAccess, xoff, yoff, xsize, ysize, bufxsize, bufysize, datatype, cache_size, page_size_hint)
4222 else:
4223 virtualmem = self.GetVirtualMem(eAccess, xoff, yoff, xsize, ysize, bufxsize, bufysize, datatype, cache_size, page_size_hint, options)
4224 return gdal_array.VirtualMemGetArray(virtualmem)
4225
4227 """Return a NumPy array for the band, seen as a virtual memory mapping.
4228 An element is accessed with array[y][x].
4229 Any reference to the array must be dropped before the last reference to the
4230 related dataset is also dropped.
4231 """
4232 from osgeo import gdal_array
4233 if options is None:
4234 virtualmem = self.GetVirtualMemAuto(eAccess)
4235 else:
4236 virtualmem = self.GetVirtualMemAuto(eAccess,options)
4237 return gdal_array.VirtualMemGetArray( virtualmem )
4238
4239 - def GetTiledVirtualMemArray(self, eAccess=gdalconst.GF_Read, xoff=0, yoff=0,
4240 xsize=None, ysize=None, tilexsize=256, tileysize=256,
4241 datatype=None,
4242 cache_size = 10 * 1024 * 1024, options=None):
4243 """Return a NumPy array for the band, seen as a virtual memory mapping with
4244 a tile organization.
4245 An element is accessed with array[tiley][tilex][y][x].
4246 Any reference to the array must be dropped before the last reference to the
4247 related dataset is also dropped.
4248 """
4249 from osgeo import gdal_array
4250 if xsize is None:
4251 xsize = self.XSize
4252 if ysize is None:
4253 ysize = self.YSize
4254 if datatype is None:
4255 datatype = self.DataType
4256 if options is None:
4257 virtualmem = self.GetTiledVirtualMem(eAccess,xoff,yoff,xsize,ysize,tilexsize,tileysize,datatype,cache_size)
4258 else:
4259 virtualmem = self.GetTiledVirtualMem(eAccess,xoff,yoff,xsize,ysize,tilexsize,tileysize,datatype,cache_size,options)
4260 return gdal_array.VirtualMemGetArray( virtualmem )
4261
4272
4273
4284
4285
4286 Band_swigregister = _gdal.Band_swigregister
4287 Band_swigregister(Band)
4288
4290 """Proxy of C++ GDALColorTableShadow class."""
4291
4292 __swig_setmethods__ = {}
4293 __setattr__ = lambda self, name, value: _swig_setattr(self, ColorTable, name, value)
4294 __swig_getmethods__ = {}
4295 __getattr__ = lambda self, name: _swig_getattr(self, ColorTable, name)
4296 __repr__ = _swig_repr
4297
4299 """__init__(GDALColorTableShadow self, GDALPaletteInterp palette) -> ColorTable"""
4300 this = _gdal.new_ColorTable(*args, **kwargs)
4301 try:
4302 self.this.append(this)
4303 except __builtin__.Exception:
4304 self.this = this
4305 __swig_destroy__ = _gdal.delete_ColorTable
4306 __del__ = lambda self: None
4307
4308 - def Clone(self, *args):
4309 """Clone(ColorTable self) -> ColorTable"""
4310 return _gdal.ColorTable_Clone(self, *args)
4311
4312
4314 """GetPaletteInterpretation(ColorTable self) -> GDALPaletteInterp"""
4315 return _gdal.ColorTable_GetPaletteInterpretation(self, *args)
4316
4317
4319 """GetCount(ColorTable self) -> int"""
4320 return _gdal.ColorTable_GetCount(self, *args)
4321
4322
4323 - def GetColorEntry(self, *args):
4324 """GetColorEntry(ColorTable self, int entry) -> ColorEntry"""
4325 return _gdal.ColorTable_GetColorEntry(self, *args)
4326
4327
4328 - def GetColorEntryAsRGB(self, *args):
4329 """GetColorEntryAsRGB(ColorTable self, int entry, ColorEntry centry) -> int"""
4330 return _gdal.ColorTable_GetColorEntryAsRGB(self, *args)
4331
4332
4333 - def SetColorEntry(self, *args):
4334 """SetColorEntry(ColorTable self, int entry, ColorEntry centry)"""
4335 return _gdal.ColorTable_SetColorEntry(self, *args)
4336
4337
4339 """CreateColorRamp(ColorTable self, int nStartIndex, ColorEntry startcolor, int nEndIndex, ColorEntry endcolor)"""
4340 return _gdal.ColorTable_CreateColorRamp(self, *args)
4341
4342 ColorTable_swigregister = _gdal.ColorTable_swigregister
4343 ColorTable_swigregister(ColorTable)
4344
4346 """Proxy of C++ GDALRasterAttributeTableShadow class."""
4347
4348 __swig_setmethods__ = {}
4349 __setattr__ = lambda self, name, value: _swig_setattr(self, RasterAttributeTable, name, value)
4350 __swig_getmethods__ = {}
4351 __getattr__ = lambda self, name: _swig_getattr(self, RasterAttributeTable, name)
4352 __repr__ = _swig_repr
4353
4355 """__init__(GDALRasterAttributeTableShadow self) -> RasterAttributeTable"""
4356 this = _gdal.new_RasterAttributeTable(*args)
4357 try:
4358 self.this.append(this)
4359 except __builtin__.Exception:
4360 self.this = this
4361 __swig_destroy__ = _gdal.delete_RasterAttributeTable
4362 __del__ = lambda self: None
4363
4364 - def Clone(self, *args):
4365 """Clone(RasterAttributeTable self) -> RasterAttributeTable"""
4366 return _gdal.RasterAttributeTable_Clone(self, *args)
4367
4368
4370 """GetColumnCount(RasterAttributeTable self) -> int"""
4371 return _gdal.RasterAttributeTable_GetColumnCount(self, *args)
4372
4373
4375 """GetNameOfCol(RasterAttributeTable self, int iCol) -> char const *"""
4376 return _gdal.RasterAttributeTable_GetNameOfCol(self, *args)
4377
4378
4380 """GetUsageOfCol(RasterAttributeTable self, int iCol) -> GDALRATFieldUsage"""
4381 return _gdal.RasterAttributeTable_GetUsageOfCol(self, *args)
4382
4383
4385 """GetTypeOfCol(RasterAttributeTable self, int iCol) -> GDALRATFieldType"""
4386 return _gdal.RasterAttributeTable_GetTypeOfCol(self, *args)
4387
4388
4390 """GetColOfUsage(RasterAttributeTable self, GDALRATFieldUsage eUsage) -> int"""
4391 return _gdal.RasterAttributeTable_GetColOfUsage(self, *args)
4392
4393
4395 """GetRowCount(RasterAttributeTable self) -> int"""
4396 return _gdal.RasterAttributeTable_GetRowCount(self, *args)
4397
4398
4400 """GetValueAsString(RasterAttributeTable self, int iRow, int iCol) -> char const *"""
4401 return _gdal.RasterAttributeTable_GetValueAsString(self, *args)
4402
4403
4405 """GetValueAsInt(RasterAttributeTable self, int iRow, int iCol) -> int"""
4406 return _gdal.RasterAttributeTable_GetValueAsInt(self, *args)
4407
4408
4410 """GetValueAsDouble(RasterAttributeTable self, int iRow, int iCol) -> double"""
4411 return _gdal.RasterAttributeTable_GetValueAsDouble(self, *args)
4412
4413
4415 """SetValueAsString(RasterAttributeTable self, int iRow, int iCol, char const * pszValue)"""
4416 return _gdal.RasterAttributeTable_SetValueAsString(self, *args)
4417
4418
4420 """SetValueAsInt(RasterAttributeTable self, int iRow, int iCol, int nValue)"""
4421 return _gdal.RasterAttributeTable_SetValueAsInt(self, *args)
4422
4423
4425 """SetValueAsDouble(RasterAttributeTable self, int iRow, int iCol, double dfValue)"""
4426 return _gdal.RasterAttributeTable_SetValueAsDouble(self, *args)
4427
4428
4430 """SetRowCount(RasterAttributeTable self, int nCount)"""
4431 return _gdal.RasterAttributeTable_SetRowCount(self, *args)
4432
4433
4435 """CreateColumn(RasterAttributeTable self, char const * pszName, GDALRATFieldType eType, GDALRATFieldUsage eUsage) -> int"""
4436 return _gdal.RasterAttributeTable_CreateColumn(self, *args)
4437
4438
4440 """GetLinearBinning(RasterAttributeTable self) -> bool"""
4441 return _gdal.RasterAttributeTable_GetLinearBinning(self, *args)
4442
4443
4445 """SetLinearBinning(RasterAttributeTable self, double dfRow0Min, double dfBinSize) -> int"""
4446 return _gdal.RasterAttributeTable_SetLinearBinning(self, *args)
4447
4448
4450 """GetRowOfValue(RasterAttributeTable self, double dfValue) -> int"""
4451 return _gdal.RasterAttributeTable_GetRowOfValue(self, *args)
4452
4453
4455 """ChangesAreWrittenToFile(RasterAttributeTable self) -> int"""
4456 return _gdal.RasterAttributeTable_ChangesAreWrittenToFile(self, *args)
4457
4458
4460 """DumpReadable(RasterAttributeTable self)"""
4461 return _gdal.RasterAttributeTable_DumpReadable(self, *args)
4462
4463
4465 """SetTableType(RasterAttributeTable self, GDALRATTableType eTableType)"""
4466 return _gdal.RasterAttributeTable_SetTableType(self, *args)
4467
4468
4470 """GetTableType(RasterAttributeTable self) -> GDALRATTableType"""
4471 return _gdal.RasterAttributeTable_GetTableType(self, *args)
4472
4473
4478
4483
4484 RasterAttributeTable_swigregister = _gdal.RasterAttributeTable_swigregister
4485 RasterAttributeTable_swigregister(RasterAttributeTable)
4486
4487
4489 """TermProgress_nocb(double dfProgress, char const * pszMessage=None, void * pData=None) -> int"""
4490 return _gdal.TermProgress_nocb(*args, **kwargs)
4491 TermProgress = _gdal.TermProgress
4492
4496
4498 """DitherRGB2PCT(Band red, Band green, Band blue, Band target, ColorTable colors, GDALProgressFunc callback=0, void * callback_data=None) -> int"""
4499 return _gdal.DitherRGB2PCT(*args, **kwargs)
4500
4502 """ReprojectImage(Dataset src_ds, Dataset dst_ds, char const * src_wkt=None, char const * dst_wkt=None, GDALResampleAlg eResampleAlg, double WarpMemoryLimit=0.0, double maxerror=0.0, GDALProgressFunc callback=0, void * callback_data=None, char ** options=None) -> CPLErr"""
4503 return _gdal.ReprojectImage(*args, **kwargs)
4504
4506 """ComputeProximity(Band srcBand, Band proximityBand, char ** options=None, GDALProgressFunc callback=0, void * callback_data=None) -> int"""
4507 return _gdal.ComputeProximity(*args, **kwargs)
4508
4510 """RasterizeLayer(Dataset dataset, int bands, Layer layer, void * pfnTransformer=None, void * pTransformArg=None, int burn_values=0, char ** options=None, GDALProgressFunc callback=0, void * callback_data=None) -> int"""
4511 return _gdal.RasterizeLayer(*args, **kwargs)
4512
4514 """Polygonize(Band srcBand, Band maskBand, Layer outLayer, int iPixValField, char ** options=None, GDALProgressFunc callback=0, void * callback_data=None) -> int"""
4515 return _gdal.Polygonize(*args, **kwargs)
4516
4518 """FPolygonize(Band srcBand, Band maskBand, Layer outLayer, int iPixValField, char ** options=None, GDALProgressFunc callback=0, void * callback_data=None) -> int"""
4519 return _gdal.FPolygonize(*args, **kwargs)
4520
4522 """FillNodata(Band targetBand, Band maskBand, double maxSearchDist, int smoothingIterations, char ** options=None, GDALProgressFunc callback=0, void * callback_data=None) -> int"""
4523 return _gdal.FillNodata(*args, **kwargs)
4524
4526 """SieveFilter(Band srcBand, Band maskBand, Band dstBand, int threshold, int connectedness=4, char ** options=None, GDALProgressFunc callback=0, void * callback_data=None) -> int"""
4527 return _gdal.SieveFilter(*args, **kwargs)
4528
4530 """RegenerateOverviews(Band srcBand, int overviewBandCount, char const * resampling, GDALProgressFunc callback=0, void * callback_data=None) -> int"""
4531 return _gdal.RegenerateOverviews(*args, **kwargs)
4532
4534 """RegenerateOverview(Band srcBand, Band overviewBand, char const * resampling, GDALProgressFunc callback=0, void * callback_data=None) -> int"""
4535 return _gdal.RegenerateOverview(*args, **kwargs)
4536
4538 """ContourGenerate(Band srcBand, double contourInterval, double contourBase, int fixedLevelCount, int useNoData, double noDataValue, Layer dstLayer, int idField, int elevField, GDALProgressFunc callback=0, void * callback_data=None) -> int"""
4539 return _gdal.ContourGenerate(*args, **kwargs)
4540
4542 """ContourGenerateEx(Band srcBand, Layer dstLayer, char ** options=None, GDALProgressFunc callback=0, void * callback_data=None) -> int"""
4543 return _gdal.ContourGenerateEx(*args, **kwargs)
4544 GVM_Diagonal = _gdal.GVM_Diagonal
4545 GVM_Edge = _gdal.GVM_Edge
4546 GVM_Max = _gdal.GVM_Max
4547 GVM_Min = _gdal.GVM_Min
4548 GVOT_NORMAL = _gdal.GVOT_NORMAL
4549 GVOT_MIN_TARGET_HEIGHT_FROM_DEM = _gdal.GVOT_MIN_TARGET_HEIGHT_FROM_DEM
4550 GVOT_MIN_TARGET_HEIGHT_FROM_GROUND = _gdal.GVOT_MIN_TARGET_HEIGHT_FROM_GROUND
4551
4553 """ViewshedGenerate(Band srcBand, char const * driverName, char const * targetRasterName, char ** creationOptions, double observerX, double observerY, double observerHeight, double targetHeight, double visibleVal, double invisibleVal, double outOfRangeVal, double noDataVal, double dfCurvCoeff, GDALViewshedMode mode, double maxDistance, GDALProgressFunc callback=0, void * callback_data=None, GDALViewshedOutputType heightMode=GVOT_NORMAL, char ** papszOptions=None) -> Dataset"""
4554 return _gdal.ViewshedGenerate(*args, **kwargs)
4555
4557 """AutoCreateWarpedVRT(Dataset src_ds, char const * src_wkt=None, char const * dst_wkt=None, GDALResampleAlg eResampleAlg, double maxerror=0.0) -> Dataset"""
4558 return _gdal.AutoCreateWarpedVRT(*args)
4559
4561 """CreatePansharpenedVRT(char const * pszXML, Band panchroBand, int nInputSpectralBands) -> Dataset"""
4562 return _gdal.CreatePansharpenedVRT(*args)
4593
4594 GDALTransformerInfoShadow_swigregister = _gdal.GDALTransformerInfoShadow_swigregister
4595 GDALTransformerInfoShadow_swigregister(GDALTransformerInfoShadow)
4596
4597
4601
4603 """_ApplyVerticalShiftGrid(Dataset src_ds, Dataset grid_ds, bool inverse=False, double srcUnitToMeter=1.0, double dstUnitToMeter=1.0, char ** options=None) -> Dataset"""
4604 return _gdal._ApplyVerticalShiftGrid(*args, **kwargs)
4605
4609
4613
4615 """VersionInfo(char const * request) -> char const *"""
4616 return _gdal.VersionInfo(*args)
4617
4621
4625
4629
4633
4637
4641
4645
4647 """GetDataTypeName(GDALDataType eDataType) -> char const *"""
4648 return _gdal.GetDataTypeName(*args)
4649
4651 """GetDataTypeByName(char const * pszDataTypeName) -> GDALDataType"""
4652 return _gdal.GetDataTypeByName(*args)
4653
4655 """DataTypeUnion(GDALDataType a, GDALDataType b) -> GDALDataType"""
4656 return _gdal.DataTypeUnion(*args)
4657
4661
4665
4667 """DecToDMS(double arg1, char const * arg2, int arg3=2) -> char const *"""
4668 return _gdal.DecToDMS(*args)
4669
4673
4677
4679 """ParseXMLString(char * pszXMLString) -> CPLXMLNode *"""
4680 return _gdal.ParseXMLString(*args)
4681
4683 """SerializeXMLTree(CPLXMLNode * xmlnode) -> retStringAndCPLFree *"""
4684 return _gdal.SerializeXMLTree(*args)
4685
4687 """GetJPEG2000Structure(char const * pszFilename, char ** options=None) -> CPLXMLNode *"""
4688 return _gdal.GetJPEG2000Structure(*args)
4689
4691 """GetJPEG2000StructureAsString(char const * pszFilename, char ** options=None) -> retStringAndCPLFree *"""
4692 return _gdal.GetJPEG2000StructureAsString(*args)
4693
4697
4701
4703 """GetDriver(int i) -> Driver"""
4704 return _gdal.GetDriver(*args)
4705
4707 """Open(char const * utf8_path, GDALAccess eAccess) -> Dataset"""
4708 return _gdal.Open(*args)
4709
4711 """OpenEx(char const * utf8_path, unsigned int nOpenFlags=0, char ** allowed_drivers=None, char ** open_options=None, char ** sibling_files=None) -> Dataset"""
4712 return _gdal.OpenEx(*args, **kwargs)
4713
4715 """OpenShared(char const * utf8_path, GDALAccess eAccess) -> Dataset"""
4716 return _gdal.OpenShared(*args)
4717
4719 """IdentifyDriver(char const * utf8_path, char ** papszSiblings=None) -> Driver"""
4720 return _gdal.IdentifyDriver(*args)
4721
4723 """IdentifyDriverEx(char const * utf8_path, unsigned int nIdentifyFlags=0, char ** allowed_drivers=None, char ** sibling_files=None) -> Driver"""
4724 return _gdal.IdentifyDriverEx(*args, **kwargs)
4725
4729
4730 __version__ = _gdal.VersionInfo("RELEASE_NAME")
4731
4750 GDALInfoOptions_swigregister = _gdal.GDALInfoOptions_swigregister
4751 GDALInfoOptions_swigregister(GDALInfoOptions)
4752
4753
4755 """InfoInternal(Dataset hDataset, GDALInfoOptions infoOptions) -> retStringAndCPLFree *"""
4756 return _gdal.InfoInternal(*args)
4775 GDALMultiDimInfoOptions_swigregister = _gdal.GDALMultiDimInfoOptions_swigregister
4776 GDALMultiDimInfoOptions_swigregister(GDALMultiDimInfoOptions)
4777
4778
4780 """MultiDimInfoInternal(Dataset hDataset, GDALMultiDimInfoOptions infoOptions) -> retStringAndCPLFree *"""
4781 return _gdal.MultiDimInfoInternal(*args)
4800 GDALTranslateOptions_swigregister = _gdal.GDALTranslateOptions_swigregister
4801 GDALTranslateOptions_swigregister(GDALTranslateOptions)
4802
4803
4805 """TranslateInternal(char const * dest, Dataset dataset, GDALTranslateOptions translateOptions, GDALProgressFunc callback=0, void * callback_data=None) -> Dataset"""
4806 return _gdal.TranslateInternal(*args)
4825 GDALWarpAppOptions_swigregister = _gdal.GDALWarpAppOptions_swigregister
4826 GDALWarpAppOptions_swigregister(GDALWarpAppOptions)
4827
4828
4830 """wrapper_GDALWarpDestDS(Dataset dstDS, int object_list_count, GDALWarpAppOptions warpAppOptions, GDALProgressFunc callback=0, void * callback_data=None) -> int"""
4831 return _gdal.wrapper_GDALWarpDestDS(*args)
4832
4834 """wrapper_GDALWarpDestName(char const * dest, int object_list_count, GDALWarpAppOptions warpAppOptions, GDALProgressFunc callback=0, void * callback_data=None) -> Dataset"""
4835 return _gdal.wrapper_GDALWarpDestName(*args)
4854 GDALVectorTranslateOptions_swigregister = _gdal.GDALVectorTranslateOptions_swigregister
4855 GDALVectorTranslateOptions_swigregister(GDALVectorTranslateOptions)
4856
4857
4859 """wrapper_GDALVectorTranslateDestDS(Dataset dstDS, Dataset srcDS, GDALVectorTranslateOptions options, GDALProgressFunc callback=0, void * callback_data=None) -> int"""
4860 return _gdal.wrapper_GDALVectorTranslateDestDS(*args)
4861
4863 """wrapper_GDALVectorTranslateDestName(char const * dest, Dataset srcDS, GDALVectorTranslateOptions options, GDALProgressFunc callback=0, void * callback_data=None) -> Dataset"""
4864 return _gdal.wrapper_GDALVectorTranslateDestName(*args)
4883 GDALDEMProcessingOptions_swigregister = _gdal.GDALDEMProcessingOptions_swigregister
4884 GDALDEMProcessingOptions_swigregister(GDALDEMProcessingOptions)
4885
4886
4888 """DEMProcessingInternal(char const * dest, Dataset dataset, char const * pszProcessing, char const * pszColorFilename, GDALDEMProcessingOptions options, GDALProgressFunc callback=0, void * callback_data=None) -> Dataset"""
4889 return _gdal.DEMProcessingInternal(*args)
4908 GDALNearblackOptions_swigregister = _gdal.GDALNearblackOptions_swigregister
4909 GDALNearblackOptions_swigregister(GDALNearblackOptions)
4910
4911
4913 """wrapper_GDALNearblackDestDS(Dataset dstDS, Dataset srcDS, GDALNearblackOptions options, GDALProgressFunc callback=0, void * callback_data=None) -> int"""
4914 return _gdal.wrapper_GDALNearblackDestDS(*args)
4915
4917 """wrapper_GDALNearblackDestName(char const * dest, Dataset srcDS, GDALNearblackOptions options, GDALProgressFunc callback=0, void * callback_data=None) -> Dataset"""
4918 return _gdal.wrapper_GDALNearblackDestName(*args)
4937 GDALGridOptions_swigregister = _gdal.GDALGridOptions_swigregister
4938 GDALGridOptions_swigregister(GDALGridOptions)
4939
4940
4942 """GridInternal(char const * dest, Dataset dataset, GDALGridOptions options, GDALProgressFunc callback=0, void * callback_data=None) -> Dataset"""
4943 return _gdal.GridInternal(*args)
4962 GDALRasterizeOptions_swigregister = _gdal.GDALRasterizeOptions_swigregister
4963 GDALRasterizeOptions_swigregister(GDALRasterizeOptions)
4964
4965
4967 """wrapper_GDALRasterizeDestDS(Dataset dstDS, Dataset srcDS, GDALRasterizeOptions options, GDALProgressFunc callback=0, void * callback_data=None) -> int"""
4968 return _gdal.wrapper_GDALRasterizeDestDS(*args)
4969
4971 """wrapper_GDALRasterizeDestName(char const * dest, Dataset srcDS, GDALRasterizeOptions options, GDALProgressFunc callback=0, void * callback_data=None) -> Dataset"""
4972 return _gdal.wrapper_GDALRasterizeDestName(*args)
4991 GDALBuildVRTOptions_swigregister = _gdal.GDALBuildVRTOptions_swigregister
4992 GDALBuildVRTOptions_swigregister(GDALBuildVRTOptions)
4993
4994
4996 """BuildVRTInternalObjects(char const * dest, int object_list_count, GDALBuildVRTOptions options, GDALProgressFunc callback=0, void * callback_data=None) -> Dataset"""
4997 return _gdal.BuildVRTInternalObjects(*args)
4998
5000 """BuildVRTInternalNames(char const * dest, char ** source_filenames, GDALBuildVRTOptions options, GDALProgressFunc callback=0, void * callback_data=None) -> Dataset"""
5001 return _gdal.BuildVRTInternalNames(*args)
5020 GDALMultiDimTranslateOptions_swigregister = _gdal.GDALMultiDimTranslateOptions_swigregister
5021 GDALMultiDimTranslateOptions_swigregister(GDALMultiDimTranslateOptions)
5022
5023
5025 """wrapper_GDALMultiDimTranslateDestName(char const * dest, int object_list_count, GDALMultiDimTranslateOptions multiDimTranslateOptions, GDALProgressFunc callback=0, void * callback_data=None) -> Dataset"""
5026 return _gdal.wrapper_GDALMultiDimTranslateDestName(*args)
5027
5028