Package osgeo :: Module ogr
[hide private]
[frames] | no frames]

Source Code for Module osgeo.ogr

   1  # This file was automatically generated by SWIG (http://www.swig.org). 
   2  # Version 3.0.12 
   3  # 
   4  # Do not make changes to this file unless you know what you are doing--modify 
   5  # the SWIG interface file instead. 
   6   
   7  from sys import version_info as _swig_python_version_info 
   8  if _swig_python_version_info >= (2, 7, 0): 
9 - def swig_import_helper():
10 import importlib 11 pkg = __name__.rpartition('.')[0] 12 mname = '.'.join((pkg, '_ogr')).lstrip('.') 13 try: 14 return importlib.import_module(mname) 15 except ImportError: 16 return importlib.import_module('_ogr')
17 _ogr = swig_import_helper() 18 del swig_import_helper 19 elif _swig_python_version_info >= (2, 6, 0):
20 - def swig_import_helper():
21 from os.path import dirname 22 import imp 23 fp = None 24 try: 25 fp, pathname, description = imp.find_module('_ogr', [dirname(__file__)]) 26 except ImportError: 27 import _ogr 28 return _ogr 29 try: 30 _mod = imp.load_module('_ogr', fp, pathname, description) 31 finally: 32 if fp is not None: 33 fp.close() 34 return _mod
35 _ogr = swig_import_helper() 36 del swig_import_helper 37 else: 38 import _ogr 39 del _swig_python_version_info 40 41 try: 42 _swig_property = property 43 except NameError: 44 pass # Python < 2.2 doesn't have 'property'. 45 46 try: 47 import builtins as __builtin__ 48 except ImportError: 49 import __builtin__ 50
51 -def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
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
70 -def _swig_setattr(self, class_type, name, value):
71 return _swig_setattr_nondynamic(self, class_type, name, value, 0)
72 73
74 -def _swig_getattr(self, class_type, name):
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
83 -def _swig_repr(self):
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:
94 - class _object:
95 pass
96 _newclass = 0 97 98 wkb25DBit = _ogr.wkb25DBit 99 wkb25Bit = _ogr.wkb25Bit 100 wkbUnknown = _ogr.wkbUnknown 101 wkbPoint = _ogr.wkbPoint 102 wkbLineString = _ogr.wkbLineString 103 wkbPolygon = _ogr.wkbPolygon 104 wkbMultiPoint = _ogr.wkbMultiPoint 105 wkbMultiLineString = _ogr.wkbMultiLineString 106 wkbMultiPolygon = _ogr.wkbMultiPolygon 107 wkbGeometryCollection = _ogr.wkbGeometryCollection 108 wkbCircularString = _ogr.wkbCircularString 109 wkbCompoundCurve = _ogr.wkbCompoundCurve 110 wkbCurvePolygon = _ogr.wkbCurvePolygon 111 wkbMultiCurve = _ogr.wkbMultiCurve 112 wkbMultiSurface = _ogr.wkbMultiSurface 113 wkbCurve = _ogr.wkbCurve 114 wkbSurface = _ogr.wkbSurface 115 wkbPolyhedralSurface = _ogr.wkbPolyhedralSurface 116 wkbTIN = _ogr.wkbTIN 117 wkbTriangle = _ogr.wkbTriangle 118 wkbNone = _ogr.wkbNone 119 wkbLinearRing = _ogr.wkbLinearRing 120 wkbCircularStringZ = _ogr.wkbCircularStringZ 121 wkbCompoundCurveZ = _ogr.wkbCompoundCurveZ 122 wkbCurvePolygonZ = _ogr.wkbCurvePolygonZ 123 wkbMultiCurveZ = _ogr.wkbMultiCurveZ 124 wkbMultiSurfaceZ = _ogr.wkbMultiSurfaceZ 125 wkbCurveZ = _ogr.wkbCurveZ 126 wkbSurfaceZ = _ogr.wkbSurfaceZ 127 wkbPolyhedralSurfaceZ = _ogr.wkbPolyhedralSurfaceZ 128 wkbTINZ = _ogr.wkbTINZ 129 wkbTriangleZ = _ogr.wkbTriangleZ 130 wkbPointM = _ogr.wkbPointM 131 wkbLineStringM = _ogr.wkbLineStringM 132 wkbPolygonM = _ogr.wkbPolygonM 133 wkbMultiPointM = _ogr.wkbMultiPointM 134 wkbMultiLineStringM = _ogr.wkbMultiLineStringM 135 wkbMultiPolygonM = _ogr.wkbMultiPolygonM 136 wkbGeometryCollectionM = _ogr.wkbGeometryCollectionM 137 wkbCircularStringM = _ogr.wkbCircularStringM 138 wkbCompoundCurveM = _ogr.wkbCompoundCurveM 139 wkbCurvePolygonM = _ogr.wkbCurvePolygonM 140 wkbMultiCurveM = _ogr.wkbMultiCurveM 141 wkbMultiSurfaceM = _ogr.wkbMultiSurfaceM 142 wkbCurveM = _ogr.wkbCurveM 143 wkbSurfaceM = _ogr.wkbSurfaceM 144 wkbPolyhedralSurfaceM = _ogr.wkbPolyhedralSurfaceM 145 wkbTINM = _ogr.wkbTINM 146 wkbTriangleM = _ogr.wkbTriangleM 147 wkbPointZM = _ogr.wkbPointZM 148 wkbLineStringZM = _ogr.wkbLineStringZM 149 wkbPolygonZM = _ogr.wkbPolygonZM 150 wkbMultiPointZM = _ogr.wkbMultiPointZM 151 wkbMultiLineStringZM = _ogr.wkbMultiLineStringZM 152 wkbMultiPolygonZM = _ogr.wkbMultiPolygonZM 153 wkbGeometryCollectionZM = _ogr.wkbGeometryCollectionZM 154 wkbCircularStringZM = _ogr.wkbCircularStringZM 155 wkbCompoundCurveZM = _ogr.wkbCompoundCurveZM 156 wkbCurvePolygonZM = _ogr.wkbCurvePolygonZM 157 wkbMultiCurveZM = _ogr.wkbMultiCurveZM 158 wkbMultiSurfaceZM = _ogr.wkbMultiSurfaceZM 159 wkbCurveZM = _ogr.wkbCurveZM 160 wkbSurfaceZM = _ogr.wkbSurfaceZM 161 wkbPolyhedralSurfaceZM = _ogr.wkbPolyhedralSurfaceZM 162 wkbTINZM = _ogr.wkbTINZM 163 wkbTriangleZM = _ogr.wkbTriangleZM 164 wkbPoint25D = _ogr.wkbPoint25D 165 wkbLineString25D = _ogr.wkbLineString25D 166 wkbPolygon25D = _ogr.wkbPolygon25D 167 wkbMultiPoint25D = _ogr.wkbMultiPoint25D 168 wkbMultiLineString25D = _ogr.wkbMultiLineString25D 169 wkbMultiPolygon25D = _ogr.wkbMultiPolygon25D 170 wkbGeometryCollection25D = _ogr.wkbGeometryCollection25D 171 OFTInteger = _ogr.OFTInteger 172 OFTIntegerList = _ogr.OFTIntegerList 173 OFTReal = _ogr.OFTReal 174 OFTRealList = _ogr.OFTRealList 175 OFTString = _ogr.OFTString 176 OFTStringList = _ogr.OFTStringList 177 OFTWideString = _ogr.OFTWideString 178 OFTWideStringList = _ogr.OFTWideStringList 179 OFTBinary = _ogr.OFTBinary 180 OFTDate = _ogr.OFTDate 181 OFTTime = _ogr.OFTTime 182 OFTDateTime = _ogr.OFTDateTime 183 OFTInteger64 = _ogr.OFTInteger64 184 OFTInteger64List = _ogr.OFTInteger64List 185 OFSTNone = _ogr.OFSTNone 186 OFSTBoolean = _ogr.OFSTBoolean 187 OFSTInt16 = _ogr.OFSTInt16 188 OFSTFloat32 = _ogr.OFSTFloat32 189 OFSTJSON = _ogr.OFSTJSON 190 OJUndefined = _ogr.OJUndefined 191 OJLeft = _ogr.OJLeft 192 OJRight = _ogr.OJRight 193 wkbXDR = _ogr.wkbXDR 194 wkbNDR = _ogr.wkbNDR 195 NullFID = _ogr.NullFID 196 ALTER_NAME_FLAG = _ogr.ALTER_NAME_FLAG 197 ALTER_TYPE_FLAG = _ogr.ALTER_TYPE_FLAG 198 ALTER_WIDTH_PRECISION_FLAG = _ogr.ALTER_WIDTH_PRECISION_FLAG 199 ALTER_NULLABLE_FLAG = _ogr.ALTER_NULLABLE_FLAG 200 ALTER__FLAG = _ogr.ALTER__FLAG 201 ALTER_DEFAULT_FLAG = _ogr.ALTER_DEFAULT_FLAG 202 ALTER_UNIQUE_FLAG = _ogr.ALTER_UNIQUE_FLAG 203 ALTER_ALL_FLAG = _ogr.ALTER_ALL_FLAG 204 F_VAL_NULL = _ogr.F_VAL_NULL 205 F_VAL_GEOM_TYPE = _ogr.F_VAL_GEOM_TYPE 206 F_VAL_WIDTH = _ogr.F_VAL_WIDTH 207 F_VAL_ALLOW_NULL_WHEN_DEFAULT = _ogr.F_VAL_ALLOW_NULL_WHEN_DEFAULT 208 F_VAL_ALL = _ogr.F_VAL_ALL 209 OLCRandomRead = _ogr.OLCRandomRead 210 OLCSequentialWrite = _ogr.OLCSequentialWrite 211 OLCRandomWrite = _ogr.OLCRandomWrite 212 OLCFastSpatialFilter = _ogr.OLCFastSpatialFilter 213 OLCFastFeatureCount = _ogr.OLCFastFeatureCount 214 OLCFastGetExtent = _ogr.OLCFastGetExtent 215 OLCCreateField = _ogr.OLCCreateField 216 OLCDeleteField = _ogr.OLCDeleteField 217 OLCReorderFields = _ogr.OLCReorderFields 218 OLCAlterFieldDefn = _ogr.OLCAlterFieldDefn 219 OLCTransactions = _ogr.OLCTransactions 220 OLCDeleteFeature = _ogr.OLCDeleteFeature 221 OLCFastSetNextByIndex = _ogr.OLCFastSetNextByIndex 222 OLCStringsAsUTF8 = _ogr.OLCStringsAsUTF8 223 OLCIgnoreFields = _ogr.OLCIgnoreFields 224 OLCCreateGeomField = _ogr.OLCCreateGeomField 225 OLCCurveGeometries = _ogr.OLCCurveGeometries 226 OLCMeasuredGeometries = _ogr.OLCMeasuredGeometries 227 ODsCCreateLayer = _ogr.ODsCCreateLayer 228 ODsCDeleteLayer = _ogr.ODsCDeleteLayer 229 ODsCCreateGeomFieldAfterCreateLayer = _ogr.ODsCCreateGeomFieldAfterCreateLayer 230 ODsCCurveGeometries = _ogr.ODsCCurveGeometries 231 ODsCTransactions = _ogr.ODsCTransactions 232 ODsCEmulatedTransactions = _ogr.ODsCEmulatedTransactions 233 ODsCMeasuredGeometries = _ogr.ODsCMeasuredGeometries 234 ODsCRandomLayerRead = _ogr.ODsCRandomLayerRead 235 ODsCRandomLayerWrite = _ogr.ODsCRandomLayerWrite 236 ODrCCreateDataSource = _ogr.ODrCCreateDataSource 237 ODrCDeleteDataSource = _ogr.ODrCDeleteDataSource 238 OLMD_FID64 = _ogr.OLMD_FID64 239 OGRERR_NONE = _ogr.OGRERR_NONE 240 OGRERR_NOT_ENOUGH_DATA = _ogr.OGRERR_NOT_ENOUGH_DATA 241 OGRERR_NOT_ENOUGH_MEMORY = _ogr.OGRERR_NOT_ENOUGH_MEMORY 242 OGRERR_UNSUPPORTED_GEOMETRY_TYPE = _ogr.OGRERR_UNSUPPORTED_GEOMETRY_TYPE 243 OGRERR_UNSUPPORTED_OPERATION = _ogr.OGRERR_UNSUPPORTED_OPERATION 244 OGRERR_CORRUPT_DATA = _ogr.OGRERR_CORRUPT_DATA 245 OGRERR_FAILURE = _ogr.OGRERR_FAILURE 246 OGRERR_UNSUPPORTED_SRS = _ogr.OGRERR_UNSUPPORTED_SRS 247 OGRERR_INVALID_HANDLE = _ogr.OGRERR_INVALID_HANDLE 248 OGRERR_NON_EXISTING_FEATURE = _ogr.OGRERR_NON_EXISTING_FEATURE 249
250 -def GetUseExceptions(*args):
251 """GetUseExceptions() -> int""" 252 return _ogr.GetUseExceptions(*args)
253
254 -def UseExceptions(*args):
255 """UseExceptions()""" 256 return _ogr.UseExceptions(*args)
257
258 -def DontUseExceptions(*args):
259 """DontUseExceptions()""" 260 return _ogr.DontUseExceptions(*args)
261 from . import osr
262 -class MajorObject(_object):
263 """Proxy of C++ GDALMajorObjectShadow class.""" 264 265 __swig_setmethods__ = {} 266 __setattr__ = lambda self, name, value: _swig_setattr(self, MajorObject, name, value) 267 __swig_getmethods__ = {} 268 __getattr__ = lambda self, name: _swig_getattr(self, MajorObject, name) 269
270 - def __init__(self, *args, **kwargs):
271 raise AttributeError("No constructor defined")
272 __repr__ = _swig_repr 273
274 - def GetDescription(self, *args):
275 """GetDescription(MajorObject self) -> char const *""" 276 return _ogr.MajorObject_GetDescription(self, *args)
277 278
279 - def SetDescription(self, *args):
280 """SetDescription(MajorObject self, char const * pszNewDesc)""" 281 return _ogr.MajorObject_SetDescription(self, *args)
282 283
284 - def GetMetadataDomainList(self, *args):
285 """GetMetadataDomainList(MajorObject self) -> char **""" 286 return _ogr.MajorObject_GetMetadataDomainList(self, *args)
287 288
289 - def GetMetadata_Dict(self, *args):
290 """GetMetadata_Dict(MajorObject self, char const * pszDomain) -> char **""" 291 return _ogr.MajorObject_GetMetadata_Dict(self, *args)
292 293
294 - def GetMetadata_List(self, *args):
295 """GetMetadata_List(MajorObject self, char const * pszDomain) -> char **""" 296 return _ogr.MajorObject_GetMetadata_List(self, *args)
297 298
299 - def SetMetadata(self, *args):
300 """ 301 SetMetadata(MajorObject self, char ** papszMetadata, char const * pszDomain) -> CPLErr 302 SetMetadata(MajorObject self, char * pszMetadataString, char const * pszDomain) -> CPLErr 303 """ 304 return _ogr.MajorObject_SetMetadata(self, *args)
305 306
307 - def GetMetadataItem(self, *args):
308 """GetMetadataItem(MajorObject self, char const * pszName, char const * pszDomain) -> char const *""" 309 return _ogr.MajorObject_GetMetadataItem(self, *args)
310 311
312 - def SetMetadataItem(self, *args):
313 """SetMetadataItem(MajorObject self, char const * pszName, char const * pszValue, char const * pszDomain) -> CPLErr""" 314 return _ogr.MajorObject_SetMetadataItem(self, *args)
315 316
317 - def GetMetadata(self, domain=''):
318 if domain[:4] == 'xml:': 319 return self.GetMetadata_List(domain) 320 return self.GetMetadata_Dict(domain)
321 322 MajorObject_swigregister = _ogr.MajorObject_swigregister 323 MajorObject_swigregister(MajorObject) 324
325 -class StyleTable(_object):
326 """Proxy of C++ OGRStyleTableShadow class.""" 327 328 __swig_setmethods__ = {} 329 __setattr__ = lambda self, name, value: _swig_setattr(self, StyleTable, name, value) 330 __swig_getmethods__ = {} 331 __getattr__ = lambda self, name: _swig_getattr(self, StyleTable, name) 332 __repr__ = _swig_repr 333
334 - def __init__(self, *args):
335 """__init__(OGRStyleTableShadow self) -> StyleTable""" 336 this = _ogr.new_StyleTable(*args) 337 try: 338 self.this.append(this) 339 except __builtin__.Exception: 340 self.this = this
341 __swig_destroy__ = _ogr.delete_StyleTable 342 __del__ = lambda self: None 343
344 - def AddStyle(self, *args):
345 """AddStyle(StyleTable self, char const * pszName, char const * pszStyleString) -> int""" 346 return _ogr.StyleTable_AddStyle(self, *args)
347 348
349 - def LoadStyleTable(self, *args):
350 """LoadStyleTable(StyleTable self, char const * utf8_path) -> int""" 351 return _ogr.StyleTable_LoadStyleTable(self, *args)
352 353
354 - def SaveStyleTable(self, *args):
355 """SaveStyleTable(StyleTable self, char const * utf8_path) -> int""" 356 return _ogr.StyleTable_SaveStyleTable(self, *args)
357 358
359 - def Find(self, *args):
360 """Find(StyleTable self, char const * pszName) -> char const *""" 361 return _ogr.StyleTable_Find(self, *args)
362 363
364 - def ResetStyleStringReading(self, *args):
365 """ResetStyleStringReading(StyleTable self)""" 366 return _ogr.StyleTable_ResetStyleStringReading(self, *args)
367 368
369 - def GetNextStyle(self, *args):
370 """GetNextStyle(StyleTable self) -> char const *""" 371 return _ogr.StyleTable_GetNextStyle(self, *args)
372 373
374 - def GetLastStyleName(self, *args):
375 """GetLastStyleName(StyleTable self) -> char const *""" 376 return _ogr.StyleTable_GetLastStyleName(self, *args)
377 378 StyleTable_swigregister = _ogr.StyleTable_swigregister 379 StyleTable_swigregister(StyleTable) 380
381 -class Driver(MajorObject):
382 """Proxy of C++ OGRDriverShadow class.""" 383 384 __swig_setmethods__ = {} 385 for _s in [MajorObject]: 386 __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) 387 __setattr__ = lambda self, name, value: _swig_setattr(self, Driver, name, value) 388 __swig_getmethods__ = {} 389 for _s in [MajorObject]: 390 __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) 391 __getattr__ = lambda self, name: _swig_getattr(self, Driver, name) 392
393 - def __init__(self, *args, **kwargs):
394 raise AttributeError("No constructor defined")
395 __repr__ = _swig_repr 396 __swig_getmethods__["name"] = _ogr.Driver_name_get 397 if _newclass: 398 name = _swig_property(_ogr.Driver_name_get) 399
400 - def CreateDataSource(self, *args, **kwargs):
401 """CreateDataSource(Driver self, char const * utf8_path, char ** options=None) -> DataSource""" 402 return _ogr.Driver_CreateDataSource(self, *args, **kwargs)
403 404
405 - def CopyDataSource(self, *args, **kwargs):
406 """CopyDataSource(Driver self, DataSource copy_ds, char const * utf8_path, char ** options=None) -> DataSource""" 407 return _ogr.Driver_CopyDataSource(self, *args, **kwargs)
408 409
410 - def Open(self, *args, **kwargs):
411 """Open(Driver self, char const * utf8_path, int update=0) -> DataSource""" 412 return _ogr.Driver_Open(self, *args, **kwargs)
413 414
415 - def DeleteDataSource(self, *args):
416 """DeleteDataSource(Driver self, char const * utf8_path) -> int""" 417 return _ogr.Driver_DeleteDataSource(self, *args)
418 419
420 - def TestCapability(self, *args):
421 """TestCapability(Driver self, char const * cap) -> bool""" 422 return _ogr.Driver_TestCapability(self, *args)
423 424
425 - def GetName(self, *args):
426 """GetName(Driver self) -> char const *""" 427 return _ogr.Driver_GetName(self, *args)
428 429
430 - def Register(self, *args):
431 """Register(Driver self)""" 432 return _ogr.Driver_Register(self, *args)
433 434
435 - def Deregister(self, *args):
436 """Deregister(Driver self)""" 437 return _ogr.Driver_Deregister(self, *args)
438 439 Driver_swigregister = _ogr.Driver_swigregister 440 Driver_swigregister(Driver) 441
442 -class DataSource(MajorObject):
443 """Proxy of C++ OGRDataSourceShadow class.""" 444 445 __swig_setmethods__ = {} 446 for _s in [MajorObject]: 447 __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) 448 __setattr__ = lambda self, name, value: _swig_setattr(self, DataSource, name, value) 449 __swig_getmethods__ = {} 450 for _s in [MajorObject]: 451 __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) 452 __getattr__ = lambda self, name: _swig_getattr(self, DataSource, name) 453
454 - def __init__(self, *args, **kwargs):
455 raise AttributeError("No constructor defined")
456 __repr__ = _swig_repr 457 __swig_getmethods__["name"] = _ogr.DataSource_name_get 458 if _newclass: 459 name = _swig_property(_ogr.DataSource_name_get) 460 __swig_destroy__ = _ogr.delete_DataSource 461 __del__ = lambda self: None 462
463 - def GetRefCount(self, *args):
464 """ 465 GetRefCount(DataSource self) -> int 466 467 int 468 OGR_DS_GetRefCount(OGRDataSourceH hDataSource) 469 """ 470 return _ogr.DataSource_GetRefCount(self, *args)
471 472
473 - def GetSummaryRefCount(self, *args):
474 """ 475 GetSummaryRefCount(DataSource self) -> int 476 477 int 478 OGR_DS_GetSummaryRefCount(OGRDataSourceH hDataSource) 479 """ 480 return _ogr.DataSource_GetSummaryRefCount(self, *args)
481 482
483 - def GetLayerCount(self, *args):
484 """ 485 GetLayerCount(DataSource self) -> int 486 487 int 488 OGR_DS_GetLayerCount(OGRDataSourceH hDS) 489 490 Get the number of layers in this data source. 491 492 Deprecated Use GDALDatasetGetLayerCount() in GDAL 2.0 493 494 Parameters: 495 ----------- 496 497 hDS: handle to the data source from which to get the number of 498 layers. 499 500 layer count. 501 """ 502 return _ogr.DataSource_GetLayerCount(self, *args)
503 504
505 - def GetDriver(self, *args):
506 """ 507 GetDriver(DataSource self) -> Driver 508 509 OGRSFDriverH 510 OGR_DS_GetDriver(OGRDataSourceH hDS) 511 512 Returns the driver that the dataset was opened with. 513 514 NOTE: Starting with GDAL 2.0, it is NOT safe to cast the returned 515 handle to OGRSFDriver*. If a C++ object is needed, the handle should 516 be cast to GDALDriver*. 517 518 Deprecated Use GDALGetDatasetDriver() in GDAL 2.0 519 520 Parameters: 521 ----------- 522 523 hDS: handle to the datasource 524 525 NULL if driver info is not available, or pointer to a driver owned by 526 the OGRSFDriverManager. 527 """ 528 return _ogr.DataSource_GetDriver(self, *args)
529 530
531 - def GetName(self, *args):
532 """ 533 GetName(DataSource self) -> char const * 534 535 const char* 536 OGR_DS_GetName(OGRDataSourceH hDS) 537 538 Returns the name of the data source. 539 540 This string should be sufficient to open the data source if passed to 541 the same OGRSFDriver that this data source was opened with, but it 542 need not be exactly the same string that was used to open the data 543 source. Normally this is a filename. 544 545 Deprecated Use GDALGetDescription() in GDAL 2.0 546 547 Parameters: 548 ----------- 549 550 hDS: handle to the data source to get the name from. 551 552 pointer to an internal name string which should not be modified or 553 freed by the caller. 554 """ 555 return _ogr.DataSource_GetName(self, *args)
556 557
558 - def DeleteLayer(self, *args):
559 """ 560 DeleteLayer(DataSource self, int index) -> OGRErr 561 562 OGRErr 563 OGR_DS_DeleteLayer(OGRDataSourceH hDS, int iLayer) 564 565 Delete the indicated layer from the datasource. 566 567 If this method is supported the ODsCDeleteLayer capability will test 568 TRUE on the OGRDataSource. 569 570 Deprecated Use GDALDatasetDeleteLayer() in GDAL 2.0 571 572 Parameters: 573 ----------- 574 575 hDS: handle to the datasource 576 577 iLayer: the index of the layer to delete. 578 579 OGRERR_NONE on success, or OGRERR_UNSUPPORTED_OPERATION if deleting 580 layers is not supported for this datasource. 581 """ 582 return _ogr.DataSource_DeleteLayer(self, *args)
583 584
585 - def SyncToDisk(self, *args):
586 """ 587 SyncToDisk(DataSource self) -> OGRErr 588 589 OGRErr 590 OGR_DS_SyncToDisk(OGRDataSourceH hDS) 591 592 Flush pending changes to disk. 593 594 See GDALDataset::FlushCache() 595 """ 596 return _ogr.DataSource_SyncToDisk(self, *args)
597 598
599 - def FlushCache(self, *args):
600 """FlushCache(DataSource self)""" 601 return _ogr.DataSource_FlushCache(self, *args)
602 603
604 - def CreateLayer(self, *args, **kwargs):
605 """ 606 CreateLayer(DataSource self, char const * name, SpatialReference srs=None, OGRwkbGeometryType geom_type, char ** options=None) -> Layer 607 608 OGRLayerH 609 OGR_DS_CreateLayer(OGRDataSourceH hDS, const char *pszName, 610 OGRSpatialReferenceH hSpatialRef, OGRwkbGeometryType eType, char 611 **papszOptions) 612 613 This function attempts to create a new layer on the data source with 614 the indicated name, coordinate system, geometry type. 615 616 The papszOptions argument can be used to control driver specific 617 creation options. These options are normally documented in the format 618 specific documentation. 619 620 Deprecated Use GDALDatasetCreateLayer() in GDAL 2.0 621 622 Parameters: 623 ----------- 624 625 hDS: The dataset handle. 626 627 pszName: the name for the new layer. This should ideally not match 628 any existing layer on the datasource. 629 630 hSpatialRef: handle to the coordinate system to use for the new 631 layer, or NULL if no coordinate system is available. The driver might 632 only increase the reference counter of the object to take ownership, 633 and not make a full copy, so do not use OSRDestroySpatialReference(), 634 but OSRRelease() instead when you are done with the object. 635 636 eType: the geometry type for the layer. Use wkbUnknown if there are 637 no constraints on the types geometry to be written. 638 639 papszOptions: a StringList of name=value options. Options are driver 640 specific, and driver information can be found at the following 641 url:http://www.gdal.org/ogr_formats.html 642 643 NULL is returned on failure, or a new OGRLayer handle on success. 644 Example: 645 """ 646 return _ogr.DataSource_CreateLayer(self, *args, **kwargs)
647 648
649 - def CopyLayer(self, *args, **kwargs):
650 """ 651 CopyLayer(DataSource self, Layer src_layer, char const * new_name, char ** options=None) -> Layer 652 653 OGRLayerH 654 OGR_DS_CopyLayer(OGRDataSourceH hDS, OGRLayerH hSrcLayer, const char 655 *pszNewName, char **papszOptions) 656 657 Duplicate an existing layer. 658 659 This function creates a new layer, duplicate the field definitions of 660 the source layer and then duplicate each features of the source layer. 661 The papszOptions argument can be used to control driver specific 662 creation options. These options are normally documented in the format 663 specific documentation. The source layer may come from another 664 dataset. 665 666 Deprecated Use GDALDatasetCopyLayer() in GDAL 2.0 667 668 Parameters: 669 ----------- 670 671 hDS: handle to the data source where to create the new layer 672 673 hSrcLayer: handle to the source layer. 674 675 pszNewName: the name of the layer to create. 676 677 papszOptions: a StringList of name=value options. Options are driver 678 specific. 679 680 a handle to the layer, or NULL if an error occurs. 681 """ 682 return _ogr.DataSource_CopyLayer(self, *args, **kwargs)
683 684
685 - def GetLayerByIndex(self, *args):
686 """GetLayerByIndex(DataSource self, int index=0) -> Layer""" 687 return _ogr.DataSource_GetLayerByIndex(self, *args)
688 689
690 - def GetLayerByName(self, *args):
691 """ 692 GetLayerByName(DataSource self, char const * layer_name) -> Layer 693 694 OGRLayerH 695 OGR_DS_GetLayerByName(OGRDataSourceH hDS, const char *pszName) 696 697 Fetch a layer by name. 698 699 The returned layer remains owned by the OGRDataSource and should not 700 be deleted by the application. 701 702 Deprecated Use GDALDatasetGetLayerByName() in GDAL 2.0 703 704 Parameters: 705 ----------- 706 707 hDS: handle to the data source from which to get the layer. 708 709 pszLayerName: Layer the layer name of the layer to fetch. 710 711 a handle to the layer, or NULL if the layer is not found or an error 712 occurs. 713 """ 714 return _ogr.DataSource_GetLayerByName(self, *args)
715 716
717 - def TestCapability(self, *args):
718 """ 719 TestCapability(DataSource self, char const * cap) -> bool 720 721 int 722 OGR_DS_TestCapability(OGRDataSourceH hDS, const char *pszCap) 723 724 Test if capability is available. 725 726 One of the following data source capability names can be passed into 727 this function, and a TRUE or FALSE value will be returned indicating 728 whether or not the capability is available for this object. 729 730 ODsCCreateLayer: True if this datasource can create new layers. 731 732 ODsCDeleteLayer: True if this datasource can delete existing layers. 733 734 ODsCCreateGeomFieldAfterCreateLayer: True if the layers of this 735 datasource support CreateGeomField() just after layer creation. 736 737 ODsCCurveGeometries: True if this datasource supports writing curve 738 geometries. (GDAL 2.0). In that case, OLCCurveGeometries must also be 739 declared in layers of that dataset. 740 741 The #define macro forms of the capability names should be used in 742 preference to the strings themselves to avoid misspelling. 743 744 Deprecated Use GDALDatasetTestCapability() in GDAL 2.0 745 746 Parameters: 747 ----------- 748 749 hDS: handle to the data source against which to test the capability. 750 751 pszCapability: the capability to test. 752 753 TRUE if capability available otherwise FALSE. 754 """ 755 return _ogr.DataSource_TestCapability(self, *args)
756 757
758 - def ExecuteSQL(self, *args, **kwargs):
759 """ 760 ExecuteSQL(DataSource self, char const * statement, Geometry spatialFilter=None, char const * dialect) -> Layer 761 762 OGRLayerH 763 OGR_DS_ExecuteSQL(OGRDataSourceH hDS, const char *pszStatement, 764 OGRGeometryH hSpatialFilter, const char *pszDialect) 765 766 Execute an SQL statement against the data store. 767 768 The result of an SQL query is either NULL for statements that are in 769 error, or that have no results set, or an OGRLayer handle representing 770 a results set from the query. Note that this OGRLayer is in addition 771 to the layers in the data store and must be destroyed with 772 OGR_DS_ReleaseResultSet() before the data source is closed 773 (destroyed). 774 775 For more information on the SQL dialect supported internally by OGR 776 review theOGR SQL document. Some drivers (i.e. Oracle and PostGIS) 777 pass the SQL directly through to the underlying RDBMS. 778 779 Starting with OGR 1.10, theSQLITE dialect can also be used. 780 781 Deprecated Use GDALDatasetExecuteSQL() in GDAL 2.0 782 783 Parameters: 784 ----------- 785 786 hDS: handle to the data source on which the SQL query is executed. 787 788 pszSQLCommand: the SQL statement to execute. 789 790 hSpatialFilter: handle to a geometry which represents a spatial 791 filter. Can be NULL. 792 793 pszDialect: allows control of the statement dialect. If set to NULL, 794 the OGR SQL engine will be used, except for RDBMS drivers that will 795 use their dedicated SQL engine, unless OGRSQL is explicitly passed as 796 the dialect. Starting with OGR 1.10, the SQLITE dialect can also be 797 used. 798 799 a handle to a OGRLayer containing the results of the query. 800 Deallocate with OGR_DS_ReleaseResultSet(). 801 """ 802 return _ogr.DataSource_ExecuteSQL(self, *args, **kwargs)
803 804
805 - def AbortSQL(self, *args):
806 """AbortSQL(DataSource self) -> OGRErr""" 807 return _ogr.DataSource_AbortSQL(self, *args)
808 809
810 - def ReleaseResultSet(self, *args):
811 """ 812 ReleaseResultSet(DataSource self, Layer layer) 813 814 void 815 OGR_DS_ReleaseResultSet(OGRDataSourceH hDS, OGRLayerH hLayer) 816 817 Release results of OGR_DS_ExecuteSQL(). 818 819 This function should only be used to deallocate OGRLayers resulting 820 from an OGR_DS_ExecuteSQL() call on the same OGRDataSource. Failure to 821 deallocate a results set before destroying the OGRDataSource may cause 822 errors. 823 824 Deprecated Use GDALDatasetReleaseResultSet() in GDAL 2.0 825 826 Parameters: 827 ----------- 828 829 hDS: a handle to the data source on which was executed an SQL query. 830 831 hLayer: handle to the result of a previous OGR_DS_ExecuteSQL() call. 832 833 """ 834 return _ogr.DataSource_ReleaseResultSet(self, *args)
835 836
837 - def GetStyleTable(self, *args):
838 """ 839 GetStyleTable(DataSource self) -> StyleTable 840 841 OGRStyleTableH 842 OGR_DS_GetStyleTable(OGRDataSourceH hDS) 843 844 Get style table. 845 """ 846 return _ogr.DataSource_GetStyleTable(self, *args)
847 848
849 - def SetStyleTable(self, *args):
850 """ 851 SetStyleTable(DataSource self, StyleTable table) 852 853 void 854 OGR_DS_SetStyleTable(OGRDataSourceH hDS, OGRStyleTableH hStyleTable) 855 856 Set style table. 857 """ 858 return _ogr.DataSource_SetStyleTable(self, *args)
859 860
861 - def StartTransaction(self, *args, **kwargs):
862 """StartTransaction(DataSource self, int force=False) -> OGRErr""" 863 return _ogr.DataSource_StartTransaction(self, *args, **kwargs)
864 865
866 - def CommitTransaction(self, *args):
867 """CommitTransaction(DataSource self) -> OGRErr""" 868 return _ogr.DataSource_CommitTransaction(self, *args)
869 870
871 - def RollbackTransaction(self, *args):
872 """RollbackTransaction(DataSource self) -> OGRErr""" 873 return _ogr.DataSource_RollbackTransaction(self, *args)
874 875
876 - def Destroy(self):
877 "Once called, self has effectively been destroyed. Do not access. For backwards compatibility only" 878 _ogr.delete_DataSource(self) 879 self.thisown = 0
880
881 - def Release(self):
882 "Once called, self has effectively been destroyed. Do not access. For backwards compatibility only" 883 _ogr.delete_DataSource(self) 884 self.thisown = 0
885
886 - def Reference(self):
887 "For backwards compatibility only." 888 return self.Reference()
889
890 - def Dereference(self):
891 "For backwards compatibility only." 892 self.Dereference()
893
894 - def __len__(self):
895 """Returns the number of layers on the datasource""" 896 return self.GetLayerCount()
897
898 - def __getitem__(self, value):
899 """Support dictionary, list, and slice -like access to the datasource. 900 ds[0] would return the first layer on the datasource. 901 ds['aname'] would return the layer named "aname". 902 ds[0:4] would return a list of the first four layers.""" 903 if isinstance(value, slice): 904 output = [] 905 step = value.step if value.step else 1 906 for i in xrange(value.start, value.stop, step): 907 lyr = self.GetLayer(i) 908 if lyr is None: 909 return output 910 output.append(lyr) 911 return output 912 if isinstance(value, int): 913 if value > len(self) - 1: 914 raise IndexError 915 return self.GetLayer(value) 916 elif isinstance(value, str): 917 return self.GetLayer(value) 918 else: 919 raise TypeError('Input %s is not of String or Int type' % type(value))
920
921 - def GetLayer(self, iLayer=0):
922 """Return the layer given an index or a name""" 923 if isinstance(iLayer, str): 924 return self.GetLayerByName(str(iLayer)) 925 elif isinstance(iLayer, int): 926 return self.GetLayerByIndex(iLayer) 927 else: 928 raise TypeError("Input %s is not of String or Int type" % type(iLayer))
929
930 - def DeleteLayer(self, value):
931 """Deletes the layer given an index or layer name""" 932 if isinstance(value, str): 933 for i in range(self.GetLayerCount()): 934 name = self.GetLayer(i).GetName() 935 if name == value: 936 return _ogr.DataSource_DeleteLayer(self, i) 937 raise ValueError("Layer %s not found to delete" % value) 938 elif isinstance(value, int): 939 return _ogr.DataSource_DeleteLayer(self, value) 940 else: 941 raise TypeError("Input %s is not of String or Int type" % type(value))
942 943 DataSource_swigregister = _ogr.DataSource_swigregister 944 DataSource_swigregister(DataSource) 945
946 -class Layer(MajorObject):
947 """Proxy of C++ OGRLayerShadow class.""" 948 949 __swig_setmethods__ = {} 950 for _s in [MajorObject]: 951 __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) 952 __setattr__ = lambda self, name, value: _swig_setattr(self, Layer, name, value) 953 __swig_getmethods__ = {} 954 for _s in [MajorObject]: 955 __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) 956 __getattr__ = lambda self, name: _swig_getattr(self, Layer, name) 957
958 - def __init__(self, *args, **kwargs):
959 raise AttributeError("No constructor defined")
960 __repr__ = _swig_repr 961
962 - def GetRefCount(self, *args):
963 """ 964 GetRefCount(Layer self) -> int 965 966 int OGR_L_GetRefCount(OGRLayerH 967 hLayer) 968 """ 969 return _ogr.Layer_GetRefCount(self, *args)
970 971
972 - def SetSpatialFilter(self, *args):
973 """ 974 SetSpatialFilter(Layer self, Geometry filter) 975 SetSpatialFilter(Layer self, int iGeomField, Geometry filter) 976 977 void 978 OGR_L_SetSpatialFilter(OGRLayerH hLayer, OGRGeometryH hGeom) 979 980 Set a new spatial filter. 981 982 This function set the geometry to be used as a spatial filter when 983 fetching features via the OGR_L_GetNextFeature() function. Only 984 features that geometrically intersect the filter geometry will be 985 returned. 986 987 Currently this test is may be inaccurately implemented, but it is 988 guaranteed that all features whose envelope (as returned by 989 OGR_G_GetEnvelope()) overlaps the envelope of the spatial filter will 990 be returned. This can result in more shapes being returned that should 991 strictly be the case. 992 993 Starting with GDAL 2.3, features with null or empty geometries will 994 never be considered as matching a spatial filter. 995 996 This function makes an internal copy of the passed geometry. The 997 passed geometry remains the responsibility of the caller, and may be 998 safely destroyed. 999 1000 For the time being the passed filter geometry should be in the same 1001 SRS as the layer (as returned by OGR_L_GetSpatialRef()). In the future 1002 this may be generalized. 1003 1004 This function is the same as the C++ method 1005 OGRLayer::SetSpatialFilter. 1006 1007 Parameters: 1008 ----------- 1009 1010 hLayer: handle to the layer on which to set the spatial filter. 1011 1012 hGeom: handle to the geometry to use as a filtering region. NULL may 1013 be passed indicating that the current spatial filter should be 1014 cleared, but no new one instituted. 1015 """ 1016 return _ogr.Layer_SetSpatialFilter(self, *args)
1017 1018
1019 - def SetSpatialFilterRect(self, *args):
1020 """ 1021 SetSpatialFilterRect(Layer self, double minx, double miny, double maxx, double maxy) 1022 SetSpatialFilterRect(Layer self, int iGeomField, double minx, double miny, double maxx, double maxy) 1023 1024 void 1025 OGR_L_SetSpatialFilterRect(OGRLayerH hLayer, double dfMinX, double 1026 dfMinY, double dfMaxX, double dfMaxY) 1027 1028 Set a new rectangular spatial filter. 1029 1030 This method set rectangle to be used as a spatial filter when fetching 1031 features via the OGR_L_GetNextFeature() method. Only features that 1032 geometrically intersect the given rectangle will be returned. 1033 1034 The x/y values should be in the same coordinate system as the layer as 1035 a whole (as returned by OGRLayer::GetSpatialRef()). Internally this 1036 method is normally implemented as creating a 5 vertex closed 1037 rectangular polygon and passing it to OGRLayer::SetSpatialFilter(). It 1038 exists as a convenience. 1039 1040 The only way to clear a spatial filter set with this method is to call 1041 OGRLayer::SetSpatialFilter(NULL). 1042 1043 This method is the same as the C++ method 1044 OGRLayer::SetSpatialFilterRect(). 1045 1046 Parameters: 1047 ----------- 1048 1049 hLayer: handle to the layer on which to set the spatial filter. 1050 1051 dfMinX: the minimum X coordinate for the rectangular region. 1052 1053 dfMinY: the minimum Y coordinate for the rectangular region. 1054 1055 dfMaxX: the maximum X coordinate for the rectangular region. 1056 1057 dfMaxY: the maximum Y coordinate for the rectangular region. 1058 """ 1059 return _ogr.Layer_SetSpatialFilterRect(self, *args)
1060 1061
1062 - def GetSpatialFilter(self, *args):
1063 """ 1064 GetSpatialFilter(Layer self) -> Geometry 1065 1066 OGRGeometryH 1067 OGR_L_GetSpatialFilter(OGRLayerH hLayer) 1068 1069 This function returns the current spatial filter for this layer. 1070 1071 The returned pointer is to an internally owned object, and should not 1072 be altered or deleted by the caller. 1073 1074 This function is the same as the C++ method 1075 OGRLayer::GetSpatialFilter(). 1076 1077 Parameters: 1078 ----------- 1079 1080 hLayer: handle to the layer to get the spatial filter from. 1081 1082 a handle to the spatial filter geometry. 1083 """ 1084 return _ogr.Layer_GetSpatialFilter(self, *args)
1085 1086
1087 - def SetAttributeFilter(self, *args):
1088 """ 1089 SetAttributeFilter(Layer self, char * filter_string) -> OGRErr 1090 1091 OGRErr 1092 OGR_L_SetAttributeFilter(OGRLayerH hLayer, const char *pszQuery) 1093 1094 Set a new attribute query. 1095 1096 This function sets the attribute query string to be used when fetching 1097 features via the OGR_L_GetNextFeature() function. Only features for 1098 which the query evaluates as true will be returned. 1099 1100 The query string should be in the format of an SQL WHERE clause. For 1101 instance "population > 1000000 and population < 5000000" where 1102 population is an attribute in the layer. The query format is a 1103 restricted form of SQL WHERE clause as defined 1104 "eq_format=restricted_where" about half way through this document: 1105 1106 http://ogdi.sourceforge.net/prop/6.2.CapabilitiesMetadata.html 1107 1108 Note that installing a query string will generally result in resetting 1109 the current reading position (ala OGR_L_ResetReading()). 1110 1111 This function is the same as the C++ method 1112 OGRLayer::SetAttributeFilter(). 1113 1114 Parameters: 1115 ----------- 1116 1117 hLayer: handle to the layer on which attribute query will be 1118 executed. 1119 1120 pszQuery: query in restricted SQL WHERE format, or NULL to clear the 1121 current query. 1122 1123 OGRERR_NONE if successfully installed, or an error code if the query 1124 expression is in error, or some other failure occurs. 1125 """ 1126 return _ogr.Layer_SetAttributeFilter(self, *args)
1127 1128
1129 - def ResetReading(self, *args):
1130 """ 1131 ResetReading(Layer self) 1132 1133 void 1134 OGR_L_ResetReading(OGRLayerH hLayer) 1135 1136 Reset feature reading to start on the first feature. 1137 1138 This affects GetNextFeature(). 1139 1140 This function is the same as the C++ method OGRLayer::ResetReading(). 1141 1142 Parameters: 1143 ----------- 1144 1145 hLayer: handle to the layer on which features are read. 1146 """ 1147 return _ogr.Layer_ResetReading(self, *args)
1148 1149
1150 - def GetName(self, *args):
1151 """ 1152 GetName(Layer self) -> char const * 1153 1154 const char* OGR_L_GetName(OGRLayerH 1155 hLayer) 1156 1157 Return the layer name. 1158 1159 This returns the same content as 1160 OGR_FD_GetName(OGR_L_GetLayerDefn(hLayer)), but for a few drivers, 1161 calling OGR_L_GetName() directly can avoid lengthy layer definition 1162 initialization. 1163 1164 This function is the same as the C++ method OGRLayer::GetName(). 1165 1166 Parameters: 1167 ----------- 1168 1169 hLayer: handle to the layer. 1170 1171 the layer name (must not been freed) 1172 1173 OGR 1.8.0 1174 """ 1175 return _ogr.Layer_GetName(self, *args)
1176 1177
1178 - def GetGeomType(self, *args):
1179 """ 1180 GetGeomType(Layer self) -> OGRwkbGeometryType 1181 1182 OGRwkbGeometryType 1183 OGR_L_GetGeomType(OGRLayerH hLayer) 1184 1185 Return the layer geometry type. 1186 1187 This returns the same result as 1188 OGR_FD_GetGeomType(OGR_L_GetLayerDefn(hLayer)), but for a few drivers, 1189 calling OGR_L_GetGeomType() directly can avoid lengthy layer 1190 definition initialization. 1191 1192 For layers with multiple geometry fields, this method only returns the 1193 geometry type of the first geometry column. For other columns, use 1194 OGR_GFld_GetType(OGR_FD_GetGeomFieldDefn(OGR_L_GetLayerDefn(hLayer), 1195 i)). For layers without any geometry field, this method returns 1196 wkbNone. 1197 1198 This function is the same as the C++ method OGRLayer::GetGeomType(). 1199 1200 Parameters: 1201 ----------- 1202 1203 hLayer: handle to the layer. 1204 1205 the geometry type 1206 1207 OGR 1.8.0 1208 """ 1209 return _ogr.Layer_GetGeomType(self, *args)
1210 1211
1212 - def GetGeometryColumn(self, *args):
1213 """ 1214 GetGeometryColumn(Layer self) -> char const * 1215 1216 const char* 1217 OGR_L_GetGeometryColumn(OGRLayerH hLayer) 1218 1219 This method returns the name of the underlying database column being 1220 used as the geometry column, or "" if not supported. 1221 1222 For layers with multiple geometry fields, this method only returns the 1223 geometry type of the first geometry column. For other columns, use OGR 1224 _GFld_GetNameRef(OGR_FD_GetGeomFieldDefn(OGR_L_GetLayerDefn(hLayer), 1225 i)). 1226 1227 This method is the same as the C++ method 1228 OGRLayer::GetGeometryColumn() 1229 1230 Parameters: 1231 ----------- 1232 1233 hLayer: handle to the layer 1234 1235 geometry column name. 1236 """ 1237 return _ogr.Layer_GetGeometryColumn(self, *args)
1238 1239
1240 - def GetFIDColumn(self, *args):
1241 """ 1242 GetFIDColumn(Layer self) -> char const * 1243 1244 const char* 1245 OGR_L_GetFIDColumn(OGRLayerH hLayer) 1246 1247 This method returns the name of the underlying database column being 1248 used as the FID column, or "" if not supported. 1249 1250 This method is the same as the C++ method OGRLayer::GetFIDColumn() 1251 1252 Parameters: 1253 ----------- 1254 1255 hLayer: handle to the layer 1256 1257 fid column name. 1258 """ 1259 return _ogr.Layer_GetFIDColumn(self, *args)
1260 1261
1262 - def GetFeature(self, *args):
1263 """ 1264 GetFeature(Layer self, GIntBig fid) -> Feature 1265 1266 OGRFeatureH 1267 OGR_L_GetFeature(OGRLayerH hLayer, GIntBig nFeatureId) 1268 1269 Fetch a feature by its identifier. 1270 1271 This function will attempt to read the identified feature. The nFID 1272 value cannot be OGRNullFID. Success or failure of this operation is 1273 unaffected by the spatial or attribute filters (and specialized 1274 implementations in drivers should make sure that they do not take into 1275 account spatial or attribute filters). 1276 1277 If this function returns a non-NULL feature, it is guaranteed that its 1278 feature id ( OGR_F_GetFID()) will be the same as nFID. 1279 1280 Use OGR_L_TestCapability(OLCRandomRead) to establish if this layer 1281 supports efficient random access reading via OGR_L_GetFeature(); 1282 however, the call should always work if the feature exists as a 1283 fallback implementation just scans all the features in the layer 1284 looking for the desired feature. 1285 1286 Sequential reads (with OGR_L_GetNextFeature()) are generally 1287 considered interrupted by a OGR_L_GetFeature() call. 1288 1289 The returned feature should be free with OGR_F_Destroy(). 1290 1291 This function is the same as the C++ method OGRLayer::GetFeature( ). 1292 1293 Parameters: 1294 ----------- 1295 1296 hLayer: handle to the layer that owned the feature. 1297 1298 nFeatureId: the feature id of the feature to read. 1299 1300 a handle to a feature now owned by the caller, or NULL on failure. 1301 """ 1302 return _ogr.Layer_GetFeature(self, *args)
1303 1304
1305 - def GetNextFeature(self, *args):
1306 """ 1307 GetNextFeature(Layer self) -> Feature 1308 1309 OGRFeatureH 1310 OGR_L_GetNextFeature(OGRLayerH hLayer) 1311 1312 Fetch the next available feature from this layer. 1313 1314 The returned feature becomes the responsibility of the caller to 1315 delete with OGR_F_Destroy(). It is critical that all features 1316 associated with an OGRLayer (more specifically an OGRFeatureDefn) be 1317 deleted before that layer/datasource is deleted. 1318 1319 Only features matching the current spatial filter (set with 1320 SetSpatialFilter()) will be returned. 1321 1322 This function implements sequential access to the features of a layer. 1323 The OGR_L_ResetReading() function can be used to start at the 1324 beginning again. 1325 1326 Features returned by OGR_GetNextFeature() may or may not be affected 1327 by concurrent modifications depending on drivers. A guaranteed way of 1328 seeing modifications in effect is to call OGR_L_ResetReading() on 1329 layers where OGR_GetNextFeature() has been called, before reading 1330 again. Structural changes in layers (field addition, deletion, ...) 1331 when a read is in progress may or may not be possible depending on 1332 drivers. If a transaction is committed/aborted, the current sequential 1333 reading may or may not be valid after that operation and a call to 1334 OGR_L_ResetReading() might be needed. 1335 1336 This function is the same as the C++ method 1337 OGRLayer::GetNextFeature(). 1338 1339 Parameters: 1340 ----------- 1341 1342 hLayer: handle to the layer from which feature are read. 1343 1344 a handle to a feature, or NULL if no more features are available. 1345 """ 1346 return _ogr.Layer_GetNextFeature(self, *args)
1347 1348
1349 - def SetNextByIndex(self, *args):
1350 """ 1351 SetNextByIndex(Layer self, GIntBig new_index) -> OGRErr 1352 1353 OGRErr 1354 OGR_L_SetNextByIndex(OGRLayerH hLayer, GIntBig nIndex) 1355 1356 Move read cursor to the nIndex'th feature in the current resultset. 1357 1358 This method allows positioning of a layer such that the 1359 GetNextFeature() call will read the requested feature, where nIndex is 1360 an absolute index into the current result set. So, setting it to 3 1361 would mean the next feature read with GetNextFeature() would have been 1362 the 4th feature to have been read if sequential reading took place 1363 from the beginning of the layer, including accounting for spatial and 1364 attribute filters. 1365 1366 Only in rare circumstances is SetNextByIndex() efficiently 1367 implemented. In all other cases the default implementation which calls 1368 ResetReading() and then calls GetNextFeature() nIndex times is used. 1369 To determine if fast seeking is available on the current layer use the 1370 TestCapability() method with a value of OLCFastSetNextByIndex. 1371 1372 This method is the same as the C++ method OGRLayer::SetNextByIndex() 1373 1374 Parameters: 1375 ----------- 1376 1377 hLayer: handle to the layer 1378 1379 nIndex: the index indicating how many steps into the result set to 1380 seek. 1381 1382 OGRERR_NONE on success or an error code. 1383 """ 1384 return _ogr.Layer_SetNextByIndex(self, *args)
1385 1386
1387 - def SetFeature(self, *args):
1388 """ 1389 SetFeature(Layer self, Feature feature) -> OGRErr 1390 1391 OGRErr OGR_L_SetFeature(OGRLayerH 1392 hLayer, OGRFeatureH hFeat) 1393 1394 Rewrite an existing feature. 1395 1396 This function will write a feature to the layer, based on the feature 1397 id within the OGRFeature. 1398 1399 Use OGR_L_TestCapability(OLCRandomWrite) to establish if this layer 1400 supports random access writing via OGR_L_SetFeature(). 1401 1402 This function is the same as the C++ method OGRLayer::SetFeature(). 1403 1404 Parameters: 1405 ----------- 1406 1407 hLayer: handle to the layer to write the feature. 1408 1409 hFeat: the feature to write. 1410 1411 OGRERR_NONE if the operation works, otherwise an appropriate error 1412 code (e.g OGRERR_NON_EXISTING_FEATURE if the feature does not exist). 1413 1414 """ 1415 return _ogr.Layer_SetFeature(self, *args)
1416 1417
1418 - def CreateFeature(self, *args):
1419 """ 1420 CreateFeature(Layer self, Feature feature) -> OGRErr 1421 1422 OGRErr 1423 OGR_L_CreateFeature(OGRLayerH hLayer, OGRFeatureH hFeat) 1424 1425 Create and write a new feature within a layer. 1426 1427 The passed feature is written to the layer as a new feature, rather 1428 than overwriting an existing one. If the feature has a feature id 1429 other than OGRNullFID, then the native implementation may use that as 1430 the feature id of the new feature, but not necessarily. Upon 1431 successful return the passed feature will have been updated with the 1432 new feature id. 1433 1434 This function is the same as the C++ method OGRLayer::CreateFeature(). 1435 1436 Parameters: 1437 ----------- 1438 1439 hLayer: handle to the layer to write the feature to. 1440 1441 hFeat: the handle of the feature to write to disk. 1442 1443 OGRERR_NONE on success. 1444 """ 1445 return _ogr.Layer_CreateFeature(self, *args)
1446 1447
1448 - def DeleteFeature(self, *args):
1449 """ 1450 DeleteFeature(Layer self, GIntBig fid) -> OGRErr 1451 1452 OGRErr 1453 OGR_L_DeleteFeature(OGRLayerH hLayer, GIntBig nFID) 1454 1455 Delete feature from layer. 1456 1457 The feature with the indicated feature id is deleted from the layer if 1458 supported by the driver. Most drivers do not support feature deletion, 1459 and will return OGRERR_UNSUPPORTED_OPERATION. The 1460 OGR_L_TestCapability() function may be called with OLCDeleteFeature to 1461 check if the driver supports feature deletion. 1462 1463 This method is the same as the C++ method OGRLayer::DeleteFeature(). 1464 1465 Parameters: 1466 ----------- 1467 1468 hLayer: handle to the layer 1469 1470 nFID: the feature id to be deleted from the layer 1471 1472 OGRERR_NONE if the operation works, otherwise an appropriate error 1473 code (e.g OGRERR_NON_EXISTING_FEATURE if the feature does not exist). 1474 1475 """ 1476 return _ogr.Layer_DeleteFeature(self, *args)
1477 1478
1479 - def SyncToDisk(self, *args):
1480 """ 1481 SyncToDisk(Layer self) -> OGRErr 1482 1483 OGRErr OGR_L_SyncToDisk(OGRLayerH 1484 hLayer) 1485 1486 Flush pending changes to disk. 1487 1488 This call is intended to force the layer to flush any pending writes 1489 to disk, and leave the disk file in a consistent state. It would not 1490 normally have any effect on read-only datasources. 1491 1492 Some layers do not implement this method, and will still return 1493 OGRERR_NONE. The default implementation just returns OGRERR_NONE. An 1494 error is only returned if an error occurs while attempting to flush to 1495 disk. 1496 1497 In any event, you should always close any opened datasource with 1498 OGR_DS_Destroy() that will ensure all data is correctly flushed. 1499 1500 This method is the same as the C++ method OGRLayer::SyncToDisk() 1501 1502 Parameters: 1503 ----------- 1504 1505 hLayer: handle to the layer 1506 1507 OGRERR_NONE if no error occurs (even if nothing is done) or an error 1508 code. 1509 """ 1510 return _ogr.Layer_SyncToDisk(self, *args)
1511 1512
1513 - def GetLayerDefn(self, *args):
1514 """ 1515 GetLayerDefn(Layer self) -> FeatureDefn 1516 1517 OGRFeatureDefnH 1518 OGR_L_GetLayerDefn(OGRLayerH hLayer) 1519 1520 Fetch the schema information for this layer. 1521 1522 The returned handle to the OGRFeatureDefn is owned by the OGRLayer, 1523 and should not be modified or freed by the application. It 1524 encapsulates the attribute schema of the features of the layer. 1525 1526 This function is the same as the C++ method OGRLayer::GetLayerDefn(). 1527 1528 Parameters: 1529 ----------- 1530 1531 hLayer: handle to the layer to get the schema information. 1532 1533 a handle to the feature definition. 1534 """ 1535 return _ogr.Layer_GetLayerDefn(self, *args)
1536 1537
1538 - def GetFeatureCount(self, *args, **kwargs):
1539 """ 1540 GetFeatureCount(Layer self, int force=1) -> GIntBig 1541 1542 GIntBig 1543 OGR_L_GetFeatureCount(OGRLayerH hLayer, int bForce) 1544 1545 Fetch the feature count in this layer. 1546 1547 Returns the number of features in the layer. For dynamic databases the 1548 count may not be exact. If bForce is FALSE, and it would be expensive 1549 to establish the feature count a value of -1 may be returned 1550 indicating that the count isn't know. If bForce is TRUE some 1551 implementations will actually scan the entire layer once to count 1552 objects. 1553 1554 The returned count takes the spatial filter into account. 1555 1556 Note that some implementations of this method may alter the read 1557 cursor of the layer. 1558 1559 This function is the same as the CPP OGRLayer::GetFeatureCount(). 1560 1561 Note: since GDAL 2.0, this method returns a GIntBig (previously a int) 1562 1563 Parameters: 1564 ----------- 1565 1566 hLayer: handle to the layer that owned the features. 1567 1568 bForce: Flag indicating whether the count should be computed even if 1569 it is expensive. 1570 1571 feature count, -1 if count not known. 1572 """ 1573 return _ogr.Layer_GetFeatureCount(self, *args, **kwargs)
1574 1575
1576 - def GetExtent(self, *args, **kwargs):
1577 """ 1578 GetExtent(Layer self, int force=1, int can_return_null=0, int geom_field=0) 1579 1580 OGRErr OGR_L_GetExtent(OGRLayerH 1581 hLayer, OGREnvelope *psExtent, int bForce) 1582 1583 Fetch the extent of this layer. 1584 1585 Returns the extent (MBR) of the data in the layer. If bForce is FALSE, 1586 and it would be expensive to establish the extent then OGRERR_FAILURE 1587 will be returned indicating that the extent isn't know. If bForce is 1588 TRUE then some implementations will actually scan the entire layer 1589 once to compute the MBR of all the features in the layer. 1590 1591 Depending on the drivers, the returned extent may or may not take the 1592 spatial filter into account. So it is safer to call OGR_L_GetExtent() 1593 without setting a spatial filter. 1594 1595 Layers without any geometry may return OGRERR_FAILURE just indicating 1596 that no meaningful extents could be collected. 1597 1598 Note that some implementations of this method may alter the read 1599 cursor of the layer. 1600 1601 This function is the same as the C++ method OGRLayer::GetExtent(). 1602 1603 Parameters: 1604 ----------- 1605 1606 hLayer: handle to the layer from which to get extent. 1607 1608 psExtent: the structure in which the extent value will be returned. 1609 1610 bForce: Flag indicating whether the extent should be computed even if 1611 it is expensive. 1612 1613 OGRERR_NONE on success, OGRERR_FAILURE if extent not known. 1614 """ 1615 return _ogr.Layer_GetExtent(self, *args, **kwargs)
1616 1617
1618 - def TestCapability(self, *args):
1619 """ 1620 TestCapability(Layer self, char const * cap) -> bool 1621 1622 int 1623 OGR_L_TestCapability(OGRLayerH hLayer, const char *pszCap) 1624 1625 Test if this layer supported the named capability. 1626 1627 The capability codes that can be tested are represented as strings, 1628 but #defined constants exists to ensure correct spelling. Specific 1629 layer types may implement class specific capabilities, but this can't 1630 generally be discovered by the caller. 1631 1632 OLCRandomRead / "RandomRead": TRUE if the GetFeature() method is 1633 implemented in an optimized way for this layer, as opposed to the 1634 default implementation using ResetReading() and GetNextFeature() to 1635 find the requested feature id. 1636 1637 OLCSequentialWrite / "SequentialWrite": TRUE if the CreateFeature() 1638 method works for this layer. Note this means that this particular 1639 layer is writable. The same OGRLayer class may returned FALSE for 1640 other layer instances that are effectively read-only. 1641 1642 OLCRandomWrite / "RandomWrite": TRUE if the SetFeature() method is 1643 operational on this layer. Note this means that this particular layer 1644 is writable. The same OGRLayer class may returned FALSE for other 1645 layer instances that are effectively read-only. 1646 1647 OLCFastSpatialFilter / "FastSpatialFilter": TRUE if this layer 1648 implements spatial filtering efficiently. Layers that effectively read 1649 all features, and test them with the OGRFeature intersection methods 1650 should return FALSE. This can be used as a clue by the application 1651 whether it should build and maintain its own spatial index for 1652 features in this layer. 1653 1654 OLCFastFeatureCount / "FastFeatureCount": TRUE if this layer can 1655 return a feature count (via OGR_L_GetFeatureCount()) efficiently, i.e. 1656 without counting the features. In some cases this will return TRUE 1657 until a spatial filter is installed after which it will return FALSE. 1658 1659 OLCFastGetExtent / "FastGetExtent": TRUE if this layer can return 1660 its data extent (via OGR_L_GetExtent()) efficiently, i.e. without 1661 scanning all the features. In some cases this will return TRUE until a 1662 spatial filter is installed after which it will return FALSE. 1663 1664 OLCFastSetNextByIndex / "FastSetNextByIndex": TRUE if this layer can 1665 perform the SetNextByIndex() call efficiently, otherwise FALSE. 1666 1667 OLCCreateField / "CreateField": TRUE if this layer can create new 1668 fields on the current layer using CreateField(), otherwise FALSE. 1669 1670 OLCCreateGeomField / "CreateGeomField": (GDAL >= 1.11) TRUE if this 1671 layer can create new geometry fields on the current layer using 1672 CreateGeomField(), otherwise FALSE. 1673 1674 OLCDeleteField / "DeleteField": TRUE if this layer can delete 1675 existing fields on the current layer using DeleteField(), otherwise 1676 FALSE. 1677 1678 OLCReorderFields / "ReorderFields": TRUE if this layer can reorder 1679 existing fields on the current layer using ReorderField() or 1680 ReorderFields(), otherwise FALSE. 1681 1682 OLCAlterFieldDefn / "AlterFieldDefn": TRUE if this layer can alter 1683 the definition of an existing field on the current layer using 1684 AlterFieldDefn(), otherwise FALSE. 1685 1686 OLCDeleteFeature / "DeleteFeature": TRUE if the DeleteFeature() 1687 method is supported on this layer, otherwise FALSE. 1688 1689 OLCStringsAsUTF8 / "StringsAsUTF8": TRUE if values of OFTString 1690 fields are assured to be in UTF-8 format. If FALSE the encoding of 1691 fields is uncertain, though it might still be UTF-8. 1692 1693 OLCTransactions / "Transactions": TRUE if the StartTransaction(), 1694 CommitTransaction() and RollbackTransaction() methods work in a 1695 meaningful way, otherwise FALSE. 1696 1697 OLCCurveGeometries / "CurveGeometries": TRUE if this layer supports 1698 writing curve geometries or may return such geometries. (GDAL 2.0). 1699 1700 This function is the same as the C++ method 1701 OGRLayer::TestCapability(). 1702 1703 Parameters: 1704 ----------- 1705 1706 hLayer: handle to the layer to get the capability from. 1707 1708 pszCap: the name of the capability to test. 1709 1710 TRUE if the layer has the requested capability, or FALSE otherwise. 1711 OGRLayers will return FALSE for any unrecognized capabilities. 1712 """ 1713 return _ogr.Layer_TestCapability(self, *args)
1714 1715
1716 - def CreateField(self, *args, **kwargs):
1717 """ 1718 CreateField(Layer self, FieldDefn field_def, int approx_ok=1) -> OGRErr 1719 1720 OGRErr 1721 OGR_L_CreateField(OGRLayerH hLayer, OGRFieldDefnH hField, int 1722 bApproxOK) 1723 1724 Create a new field on a layer. 1725 1726 You must use this to create new fields on a real layer. Internally the 1727 OGRFeatureDefn for the layer will be updated to reflect the new field. 1728 Applications should never modify the OGRFeatureDefn used by a layer 1729 directly. 1730 1731 This function should not be called while there are feature objects in 1732 existence that were obtained or created with the previous layer 1733 definition. 1734 1735 Not all drivers support this function. You can query a layer to check 1736 if it supports it with the OLCCreateField capability. Some drivers may 1737 only support this method while there are still no features in the 1738 layer. When it is supported, the existing features of the backing 1739 file/database should be updated accordingly. 1740 1741 Drivers may or may not support not-null constraints. If they support 1742 creating fields with not-null constraints, this is generally before 1743 creating any feature to the layer. 1744 1745 This function is the same as the C++ method OGRLayer::CreateField(). 1746 1747 Parameters: 1748 ----------- 1749 1750 hLayer: handle to the layer to write the field definition. 1751 1752 hField: handle of the field definition to write to disk. 1753 1754 bApproxOK: If TRUE, the field may be created in a slightly different 1755 form depending on the limitations of the format driver. 1756 1757 OGRERR_NONE on success. 1758 """ 1759 return _ogr.Layer_CreateField(self, *args, **kwargs)
1760 1761
1762 - def DeleteField(self, *args):
1763 """ 1764 DeleteField(Layer self, int iField) -> OGRErr 1765 1766 OGRErr 1767 OGR_L_DeleteField(OGRLayerH hLayer, int iField) 1768 1769 Delete an existing field on a layer. 1770 1771 You must use this to delete existing fields on a real layer. 1772 Internally the OGRFeatureDefn for the layer will be updated to reflect 1773 the deleted field. Applications should never modify the OGRFeatureDefn 1774 used by a layer directly. 1775 1776 This function should not be called while there are feature objects in 1777 existence that were obtained or created with the previous layer 1778 definition. 1779 1780 Not all drivers support this function. You can query a layer to check 1781 if it supports it with the OLCDeleteField capability. Some drivers may 1782 only support this method while there are still no features in the 1783 layer. When it is supported, the existing features of the backing 1784 file/database should be updated accordingly. 1785 1786 This function is the same as the C++ method OGRLayer::DeleteField(). 1787 1788 Parameters: 1789 ----------- 1790 1791 hLayer: handle to the layer. 1792 1793 iField: index of the field to delete. 1794 1795 OGRERR_NONE on success. 1796 1797 OGR 1.9.0 1798 """ 1799 return _ogr.Layer_DeleteField(self, *args)
1800 1801
1802 - def ReorderField(self, *args):
1803 """ 1804 ReorderField(Layer self, int iOldFieldPos, int iNewFieldPos) -> OGRErr 1805 1806 OGRErr 1807 OGR_L_ReorderField(OGRLayerH hLayer, int iOldFieldPos, int 1808 iNewFieldPos) 1809 1810 Reorder an existing field on a layer. 1811 1812 This function is a convenience wrapper of OGR_L_ReorderFields() 1813 dedicated to move a single field. 1814 1815 You must use this to reorder existing fields on a real layer. 1816 Internally the OGRFeatureDefn for the layer will be updated to reflect 1817 the reordering of the fields. Applications should never modify the 1818 OGRFeatureDefn used by a layer directly. 1819 1820 This function should not be called while there are feature objects in 1821 existence that were obtained or created with the previous layer 1822 definition. 1823 1824 The field definition that was at initial position iOldFieldPos will be 1825 moved at position iNewFieldPos, and elements between will be shuffled 1826 accordingly. 1827 1828 For example, let suppose the fields were "0","1","2","3","4" 1829 initially. ReorderField(1, 3) will reorder them as 1830 "0","2","3","1","4". 1831 1832 Not all drivers support this function. You can query a layer to check 1833 if it supports it with the OLCReorderFields capability. Some drivers 1834 may only support this method while there are still no features in the 1835 layer. When it is supported, the existing features of the backing 1836 file/database should be updated accordingly. 1837 1838 This function is the same as the C++ method OGRLayer::ReorderField(). 1839 1840 Parameters: 1841 ----------- 1842 1843 hLayer: handle to the layer. 1844 1845 iOldFieldPos: previous position of the field to move. Must be in the 1846 range [0,GetFieldCount()-1]. 1847 1848 iNewFieldPos: new position of the field to move. Must be in the range 1849 [0,GetFieldCount()-1]. 1850 1851 OGRERR_NONE on success. 1852 1853 OGR 1.9.0 1854 """ 1855 return _ogr.Layer_ReorderField(self, *args)
1856 1857
1858 - def ReorderFields(self, *args):
1859 """ 1860 ReorderFields(Layer self, int nList) -> OGRErr 1861 1862 OGRErr 1863 OGR_L_ReorderFields(OGRLayerH hLayer, int *panMap) 1864 1865 Reorder all the fields of a layer. 1866 1867 You must use this to reorder existing fields on a real layer. 1868 Internally the OGRFeatureDefn for the layer will be updated to reflect 1869 the reordering of the fields. Applications should never modify the 1870 OGRFeatureDefn used by a layer directly. 1871 1872 This function should not be called while there are feature objects in 1873 existence that were obtained or created with the previous layer 1874 definition. 1875 1876 panMap is such that,for each field definition at position i after 1877 reordering, its position before reordering was panMap[i]. 1878 1879 For example, let suppose the fields were "0","1","2","3","4" 1880 initially. ReorderFields([0,2,3,1,4]) will reorder them as 1881 "0","2","3","1","4". 1882 1883 Not all drivers support this function. You can query a layer to check 1884 if it supports it with the OLCReorderFields capability. Some drivers 1885 may only support this method while there are still no features in the 1886 layer. When it is supported, the existing features of the backing 1887 file/database should be updated accordingly. 1888 1889 This function is the same as the C++ method OGRLayer::ReorderFields(). 1890 1891 Parameters: 1892 ----------- 1893 1894 hLayer: handle to the layer. 1895 1896 panMap: an array of GetLayerDefn()-> OGRFeatureDefn::GetFieldCount() 1897 elements which is a permutation of [0, GetLayerDefn()-> 1898 OGRFeatureDefn::GetFieldCount()-1]. 1899 1900 OGRERR_NONE on success. 1901 1902 OGR 1.9.0 1903 """ 1904 return _ogr.Layer_ReorderFields(self, *args)
1905 1906
1907 - def AlterFieldDefn(self, *args):
1908 """ 1909 AlterFieldDefn(Layer self, int iField, FieldDefn field_def, int nFlags) -> OGRErr 1910 1911 OGRErr 1912 OGR_L_AlterFieldDefn(OGRLayerH hLayer, int iField, OGRFieldDefnH 1913 hNewFieldDefn, int nFlags) 1914 1915 Alter the definition of an existing field on a layer. 1916 1917 You must use this to alter the definition of an existing field of a 1918 real layer. Internally the OGRFeatureDefn for the layer will be 1919 updated to reflect the altered field. Applications should never modify 1920 the OGRFeatureDefn used by a layer directly. 1921 1922 This function should not be called while there are feature objects in 1923 existence that were obtained or created with the previous layer 1924 definition. 1925 1926 Not all drivers support this function. You can query a layer to check 1927 if it supports it with the OLCAlterFieldDefn capability. Some drivers 1928 may only support this method while there are still no features in the 1929 layer. When it is supported, the existing features of the backing 1930 file/database should be updated accordingly. Some drivers might also 1931 not support all update flags. 1932 1933 This function is the same as the C++ method 1934 OGRLayer::AlterFieldDefn(). 1935 1936 Parameters: 1937 ----------- 1938 1939 hLayer: handle to the layer. 1940 1941 iField: index of the field whose definition must be altered. 1942 1943 hNewFieldDefn: new field definition 1944 1945 nFlags: combination of ALTER_NAME_FLAG, ALTER_TYPE_FLAG, 1946 ALTER_WIDTH_PRECISION_FLAG, ALTER_NULLABLE_FLAG and ALTER_DEFAULT_FLAG 1947 to indicate which of the name and/or type and/or width and precision 1948 fields and/or nullability from the new field definition must be taken 1949 into account. 1950 1951 OGRERR_NONE on success. 1952 1953 OGR 1.9.0 1954 """ 1955 return _ogr.Layer_AlterFieldDefn(self, *args)
1956 1957
1958 - def CreateGeomField(self, *args, **kwargs):
1959 """ 1960 CreateGeomField(Layer self, GeomFieldDefn field_def, int approx_ok=1) -> OGRErr 1961 1962 OGRErr 1963 OGR_L_CreateGeomField(OGRLayerH hLayer, OGRGeomFieldDefnH hField, int 1964 bApproxOK) 1965 1966 Create a new geometry field on a layer. 1967 1968 You must use this to create new geometry fields on a real layer. 1969 Internally the OGRFeatureDefn for the layer will be updated to reflect 1970 the new field. Applications should never modify the OGRFeatureDefn 1971 used by a layer directly. 1972 1973 This function should not be called while there are feature objects in 1974 existence that were obtained or created with the previous layer 1975 definition. 1976 1977 Not all drivers support this function. You can query a layer to check 1978 if it supports it with the OLCCreateField capability. Some drivers may 1979 only support this method while there are still no features in the 1980 layer. When it is supported, the existing features of the backing 1981 file/database should be updated accordingly. 1982 1983 Drivers may or may not support not-null constraints. If they support 1984 creating fields with not-null constraints, this is generally before 1985 creating any feature to the layer. 1986 1987 This function is the same as the C++ method OGRLayer::CreateField(). 1988 1989 Parameters: 1990 ----------- 1991 1992 hLayer: handle to the layer to write the field definition. 1993 1994 hField: handle of the geometry field definition to write to disk. 1995 1996 bApproxOK: If TRUE, the field may be created in a slightly different 1997 form depending on the limitations of the format driver. 1998 1999 OGRERR_NONE on success. 2000 2001 OGR 1.11 2002 """ 2003 return _ogr.Layer_CreateGeomField(self, *args, **kwargs)
2004 2005
2006 - def StartTransaction(self, *args):
2007 """ 2008 StartTransaction(Layer self) -> OGRErr 2009 2010 OGRErr 2011 OGR_L_StartTransaction(OGRLayerH hLayer) 2012 2013 For datasources which support transactions, StartTransaction creates a 2014 transaction. 2015 2016 If starting the transaction fails, will return OGRERR_FAILURE. 2017 Datasources which do not support transactions will always return 2018 OGRERR_NONE. 2019 2020 Note: as of GDAL 2.0, use of this API is discouraged when the dataset 2021 offers dataset level transaction with GDALDataset::StartTransaction(). 2022 The reason is that most drivers can only offer transactions at dataset 2023 level, and not layer level. Very few drivers really support 2024 transactions at layer scope. 2025 2026 This function is the same as the C++ method 2027 OGRLayer::StartTransaction(). 2028 2029 Parameters: 2030 ----------- 2031 2032 hLayer: handle to the layer 2033 2034 OGRERR_NONE on success. 2035 """ 2036 return _ogr.Layer_StartTransaction(self, *args)
2037 2038
2039 - def CommitTransaction(self, *args):
2040 """ 2041 CommitTransaction(Layer self) -> OGRErr 2042 2043 OGRErr 2044 OGR_L_CommitTransaction(OGRLayerH hLayer) 2045 2046 For datasources which support transactions, CommitTransaction commits 2047 a transaction. 2048 2049 If no transaction is active, or the commit fails, will return 2050 OGRERR_FAILURE. Datasources which do not support transactions will 2051 always return OGRERR_NONE. 2052 2053 This function is the same as the C++ method 2054 OGRLayer::CommitTransaction(). 2055 2056 Parameters: 2057 ----------- 2058 2059 hLayer: handle to the layer 2060 2061 OGRERR_NONE on success. 2062 """ 2063 return _ogr.Layer_CommitTransaction(self, *args)
2064 2065
2066 - def RollbackTransaction(self, *args):
2067 """ 2068 RollbackTransaction(Layer self) -> OGRErr 2069 2070 OGRErr 2071 OGR_L_RollbackTransaction(OGRLayerH hLayer) 2072 2073 For datasources which support transactions, RollbackTransaction will 2074 roll back a datasource to its state before the start of the current 2075 transaction. 2076 2077 If no transaction is active, or the rollback fails, will return 2078 OGRERR_FAILURE. Datasources which do not support transactions will 2079 always return OGRERR_NONE. 2080 2081 This function is the same as the C++ method 2082 OGRLayer::RollbackTransaction(). 2083 2084 Parameters: 2085 ----------- 2086 2087 hLayer: handle to the layer 2088 2089 OGRERR_NONE on success. 2090 """ 2091 return _ogr.Layer_RollbackTransaction(self, *args)
2092 2093
2094 - def FindFieldIndex(self, *args):
2095 """ 2096 FindFieldIndex(Layer self, char const * pszFieldName, int bExactMatch) -> int 2097 2098 int 2099 OGR_L_FindFieldIndex(OGRLayerH hLayer, const char *pszFieldName, int 2100 bExactMatch) 2101 2102 Find the index of field in a layer. 2103 2104 The returned number is the index of the field in the layers, or -1 if 2105 the field doesn't exist. 2106 2107 If bExactMatch is set to FALSE and the field doesn't exists in the 2108 given form the driver might apply some changes to make it match, like 2109 those it might do if the layer was created (eg. like LAUNDER in the 2110 OCI driver). 2111 2112 This method is the same as the C++ method OGRLayer::FindFieldIndex(). 2113 2114 field index, or -1 if the field doesn't exist 2115 """ 2116 return _ogr.Layer_FindFieldIndex(self, *args)
2117 2118
2119 - def GetSpatialRef(self, *args):
2120 """ 2121 GetSpatialRef(Layer self) -> SpatialReference 2122 2123 OGRSpatialReferenceH 2124 OGR_L_GetSpatialRef(OGRLayerH hLayer) 2125 2126 Fetch the spatial reference system for this layer. 2127 2128 The returned object is owned by the OGRLayer and should not be 2129 modified or freed by the application. 2130 2131 This function is the same as the C++ method OGRLayer::GetSpatialRef(). 2132 2133 Parameters: 2134 ----------- 2135 2136 hLayer: handle to the layer to get the spatial reference from. 2137 2138 spatial reference, or NULL if there isn't one. 2139 """ 2140 return _ogr.Layer_GetSpatialRef(self, *args)
2141 2142
2143 - def GetFeaturesRead(self, *args):
2144 """ 2145 GetFeaturesRead(Layer self) -> GIntBig 2146 2147 GIntBig 2148 OGR_L_GetFeaturesRead(OGRLayerH hLayer) 2149 """ 2150 return _ogr.Layer_GetFeaturesRead(self, *args)
2151 2152
2153 - def SetIgnoredFields(self, *args):
2154 """ 2155 SetIgnoredFields(Layer self, char const ** options) -> OGRErr 2156 2157 OGRErr 2158 OGR_L_SetIgnoredFields(OGRLayerH hLayer, const char **papszFields) 2159 2160 Set which fields can be omitted when retrieving features from the 2161 layer. 2162 2163 If the driver supports this functionality (testable using 2164 OLCIgnoreFields capability), it will not fetch the specified fields in 2165 subsequent calls to GetFeature() / GetNextFeature() and thus save some 2166 processing time and/or bandwidth. 2167 2168 Besides field names of the layers, the following special fields can be 2169 passed: "OGR_GEOMETRY" to ignore geometry and "OGR_STYLE" to 2170 ignore layer style. 2171 2172 By default, no fields are ignored. 2173 2174 This method is the same as the C++ method OGRLayer::SetIgnoredFields() 2175 2176 Parameters: 2177 ----------- 2178 2179 papszFields: an array of field names terminated by NULL item. If NULL 2180 is passed, the ignored list is cleared. 2181 2182 OGRERR_NONE if all field names have been resolved (even if the driver 2183 does not support this method) 2184 """ 2185 return _ogr.Layer_SetIgnoredFields(self, *args)
2186 2187
2188 - def Intersection(self, *args, **kwargs):
2189 """ 2190 Intersection(Layer self, Layer method_layer, Layer result_layer, char ** options=None, GDALProgressFunc callback=0, void * callback_data=None) -> OGRErr 2191 2192 OGRErr 2193 OGR_L_Intersection(OGRLayerH pLayerInput, OGRLayerH pLayerMethod, 2194 OGRLayerH pLayerResult, char **papszOptions, GDALProgressFunc 2195 pfnProgress, void *pProgressArg) 2196 2197 Intersection of two layers. 2198 2199 The result layer contains features whose geometries represent areas 2200 that are common between features in the input layer and in the method 2201 layer. The features in the result layer have attributes from both 2202 input and method layers. The schema of the result layer can be set by 2203 the user or, if it is empty, is initialized to contain all fields in 2204 the input and method layers. 2205 2206 If the schema of the result is set by user and contains fields that 2207 have the same name as a field in input and in method layer, then the 2208 attribute in the result feature will get the value from the feature of 2209 the method layer. 2210 2211 For best performance use the minimum amount of features in the method 2212 layer and copy it into a memory layer. 2213 2214 This method relies on GEOS support. Do not use unless the GEOS support 2215 is compiled in. The recognized list of options is : 2216 SKIP_FAILURES=YES/NO. Set it to YES to go on, even when a feature 2217 could not be inserted or a GEOS call failed. 2218 2219 PROMOTE_TO_MULTI=YES/NO. Set it to YES to convert Polygons into 2220 MultiPolygons, or LineStrings to MultiLineStrings. 2221 2222 INPUT_PREFIX=string. Set a prefix for the field names that will be 2223 created from the fields of the input layer. 2224 2225 METHOD_PREFIX=string. Set a prefix for the field names that will be 2226 created from the fields of the method layer. 2227 2228 USE_PREPARED_GEOMETRIES=YES/NO. Set to NO to not use prepared 2229 geometries to pretest intersection of features of method layer with 2230 features of this layer. 2231 2232 PRETEST_CONTAINMENT=YES/NO. Set to YES to pretest the containment of 2233 features of method layer within the features of this layer. This will 2234 speed up the method significantly in some cases. Requires that the 2235 prepared geometries are in effect. 2236 2237 KEEP_LOWER_DIMENSION_GEOMETRIES=YES/NO. Set to NO to skip result 2238 features with lower dimension geometry that would otherwise be added 2239 to the result layer. The default is to add but only if the result 2240 layer has an unknown geometry type. 2241 2242 This function is the same as the C++ method OGRLayer::Intersection(). 2243 2244 Parameters: 2245 ----------- 2246 2247 pLayerInput: the input layer. Should not be NULL. 2248 2249 pLayerMethod: the method layer. Should not be NULL. 2250 2251 pLayerResult: the layer where the features resulting from the 2252 operation are inserted. Should not be NULL. See above the note about 2253 the schema. 2254 2255 papszOptions: NULL terminated list of options (may be NULL). 2256 2257 pfnProgress: a GDALProgressFunc() compatible callback function for 2258 reporting progress or NULL. 2259 2260 pProgressArg: argument to be passed to pfnProgress. May be NULL. 2261 2262 an error code if there was an error or the execution was interrupted, 2263 OGRERR_NONE otherwise. 2264 2265 The first geometry field is always used. 2266 2267 OGR 1.10 2268 """ 2269 return _ogr.Layer_Intersection(self, *args, **kwargs)
2270 2271
2272 - def Union(self, *args, **kwargs):
2273 """ 2274 Union(Layer self, Layer method_layer, Layer result_layer, char ** options=None, GDALProgressFunc callback=0, void * callback_data=None) -> OGRErr 2275 2276 OGRErr OGR_L_Union(OGRLayerH 2277 pLayerInput, OGRLayerH pLayerMethod, OGRLayerH pLayerResult, char 2278 **papszOptions, GDALProgressFunc pfnProgress, void *pProgressArg) 2279 2280 Union of two layers. 2281 2282 The result layer contains features whose geometries represent areas 2283 that are in either in the input layer, in the method layer, or in 2284 both. The features in the result layer have attributes from both input 2285 and method layers. For features which represent areas that are only in 2286 the input or in the method layer the respective attributes have 2287 undefined values. The schema of the result layer can be set by the 2288 user or, if it is empty, is initialized to contain all fields in the 2289 input and method layers. 2290 2291 If the schema of the result is set by user and contains fields that 2292 have the same name as a field in input and in method layer, then the 2293 attribute in the result feature will get the value from the feature of 2294 the method layer (even if it is undefined). 2295 2296 For best performance use the minimum amount of features in the method 2297 layer and copy it into a memory layer. 2298 2299 This method relies on GEOS support. Do not use unless the GEOS support 2300 is compiled in. The recognized list of options is : 2301 SKIP_FAILURES=YES/NO. Set it to YES to go on, even when a feature 2302 could not be inserted or a GEOS call failed. 2303 2304 PROMOTE_TO_MULTI=YES/NO. Set it to YES to convert Polygons into 2305 MultiPolygons, or LineStrings to MultiLineStrings. 2306 2307 INPUT_PREFIX=string. Set a prefix for the field names that will be 2308 created from the fields of the input layer. 2309 2310 METHOD_PREFIX=string. Set a prefix for the field names that will be 2311 created from the fields of the method layer. 2312 2313 USE_PREPARED_GEOMETRIES=YES/NO. Set to NO to not use prepared 2314 geometries to pretest intersection of features of method layer with 2315 features of this layer. 2316 2317 KEEP_LOWER_DIMENSION_GEOMETRIES=YES/NO. Set to NO to skip result 2318 features with lower dimension geometry that would otherwise be added 2319 to the result layer. The default is to add but only if the result 2320 layer has an unknown geometry type. 2321 2322 This function is the same as the C++ method OGRLayer::Union(). 2323 2324 Parameters: 2325 ----------- 2326 2327 pLayerInput: the input layer. Should not be NULL. 2328 2329 pLayerMethod: the method layer. Should not be NULL. 2330 2331 pLayerResult: the layer where the features resulting from the 2332 operation are inserted. Should not be NULL. See above the note about 2333 the schema. 2334 2335 papszOptions: NULL terminated list of options (may be NULL). 2336 2337 pfnProgress: a GDALProgressFunc() compatible callback function for 2338 reporting progress or NULL. 2339 2340 pProgressArg: argument to be passed to pfnProgress. May be NULL. 2341 2342 an error code if there was an error or the execution was interrupted, 2343 OGRERR_NONE otherwise. 2344 2345 The first geometry field is always used. 2346 2347 OGR 1.10 2348 """ 2349 return _ogr.Layer_Union(self, *args, **kwargs)
2350 2351
2352 - def SymDifference(self, *args, **kwargs):
2353 """ 2354 SymDifference(Layer self, Layer method_layer, Layer result_layer, char ** options=None, GDALProgressFunc callback=0, void * callback_data=None) -> OGRErr 2355 2356 OGRErr 2357 OGR_L_SymDifference(OGRLayerH pLayerInput, OGRLayerH pLayerMethod, 2358 OGRLayerH pLayerResult, char **papszOptions, GDALProgressFunc 2359 pfnProgress, void *pProgressArg) 2360 2361 Symmetrical difference of two layers. 2362 2363 The result layer contains features whose geometries represent areas 2364 that are in either in the input layer or in the method layer but not 2365 in both. The features in the result layer have attributes from both 2366 input and method layers. For features which represent areas that are 2367 only in the input or in the method layer the respective attributes 2368 have undefined values. The schema of the result layer can be set by 2369 the user or, if it is empty, is initialized to contain all fields in 2370 the input and method layers. 2371 2372 If the schema of the result is set by user and contains fields that 2373 have the same name as a field in input and in method layer, then the 2374 attribute in the result feature will get the value from the feature of 2375 the method layer (even if it is undefined). 2376 2377 For best performance use the minimum amount of features in the method 2378 layer and copy it into a memory layer. 2379 2380 This method relies on GEOS support. Do not use unless the GEOS support 2381 is compiled in. The recognized list of options is : 2382 SKIP_FAILURES=YES/NO. Set it to YES to go on, even when a feature 2383 could not be inserted or a GEOS call failed. 2384 2385 PROMOTE_TO_MULTI=YES/NO. Set it to YES to convert Polygons into 2386 MultiPolygons, or LineStrings to MultiLineStrings. 2387 2388 INPUT_PREFIX=string. Set a prefix for the field names that will be 2389 created from the fields of the input layer. 2390 2391 METHOD_PREFIX=string. Set a prefix for the field names that will be 2392 created from the fields of the method layer. 2393 2394 This function is the same as the C++ method OGRLayer::SymDifference(). 2395 2396 Parameters: 2397 ----------- 2398 2399 pLayerInput: the input layer. Should not be NULL. 2400 2401 pLayerMethod: the method layer. Should not be NULL. 2402 2403 pLayerResult: the layer where the features resulting from the 2404 operation are inserted. Should not be NULL. See above the note about 2405 the schema. 2406 2407 papszOptions: NULL terminated list of options (may be NULL). 2408 2409 pfnProgress: a GDALProgressFunc() compatible callback function for 2410 reporting progress or NULL. 2411 2412 pProgressArg: argument to be passed to pfnProgress. May be NULL. 2413 2414 an error code if there was an error or the execution was interrupted, 2415 OGRERR_NONE otherwise. 2416 2417 The first geometry field is always used. 2418 2419 OGR 1.10 2420 """ 2421 return _ogr.Layer_SymDifference(self, *args, **kwargs)
2422 2423
2424 - def Identity(self, *args, **kwargs):
2425 """ 2426 Identity(Layer self, Layer method_layer, Layer result_layer, char ** options=None, GDALProgressFunc callback=0, void * callback_data=None) -> OGRErr 2427 2428 OGRErr OGR_L_Identity(OGRLayerH 2429 pLayerInput, OGRLayerH pLayerMethod, OGRLayerH pLayerResult, char 2430 **papszOptions, GDALProgressFunc pfnProgress, void *pProgressArg) 2431 2432 Identify the features of this layer with the ones from the identity 2433 layer. 2434 2435 The result layer contains features whose geometries represent areas 2436 that are in the input layer. The features in the result layer have 2437 attributes from both input and method layers. The schema of the result 2438 layer can be set by the user or, if it is empty, is initialized to 2439 contain all fields in input and method layers. 2440 2441 If the schema of the result is set by user and contains fields that 2442 have the same name as a field in input and in method layer, then the 2443 attribute in the result feature will get the value from the feature of 2444 the method layer (even if it is undefined). 2445 2446 For best performance use the minimum amount of features in the method 2447 layer and copy it into a memory layer. 2448 2449 This method relies on GEOS support. Do not use unless the GEOS support 2450 is compiled in. The recognized list of options is : 2451 SKIP_FAILURES=YES/NO. Set it to YES to go on, even when a feature 2452 could not be inserted or a GEOS call failed. 2453 2454 PROMOTE_TO_MULTI=YES/NO. Set it to YES to convert Polygons into 2455 MultiPolygons, or LineStrings to MultiLineStrings. 2456 2457 INPUT_PREFIX=string. Set a prefix for the field names that will be 2458 created from the fields of the input layer. 2459 2460 METHOD_PREFIX=string. Set a prefix for the field names that will be 2461 created from the fields of the method layer. 2462 2463 USE_PREPARED_GEOMETRIES=YES/NO. Set to NO to not use prepared 2464 geometries to pretest intersection of features of method layer with 2465 features of this layer. 2466 2467 KEEP_LOWER_DIMENSION_GEOMETRIES=YES/NO. Set to NO to skip result 2468 features with lower dimension geometry that would otherwise be added 2469 to the result layer. The default is to add but only if the result 2470 layer has an unknown geometry type. 2471 2472 This function is the same as the C++ method OGRLayer::Identity(). 2473 2474 Parameters: 2475 ----------- 2476 2477 pLayerInput: the input layer. Should not be NULL. 2478 2479 pLayerMethod: the method layer. Should not be NULL. 2480 2481 pLayerResult: the layer where the features resulting from the 2482 operation are inserted. Should not be NULL. See above the note about 2483 the schema. 2484 2485 papszOptions: NULL terminated list of options (may be NULL). 2486 2487 pfnProgress: a GDALProgressFunc() compatible callback function for 2488 reporting progress or NULL. 2489 2490 pProgressArg: argument to be passed to pfnProgress. May be NULL. 2491 2492 an error code if there was an error or the execution was interrupted, 2493 OGRERR_NONE otherwise. 2494 2495 The first geometry field is always used. 2496 2497 OGR 1.10 2498 """ 2499 return _ogr.Layer_Identity(self, *args, **kwargs)
2500 2501
2502 - def Update(self, *args, **kwargs):
2503 """ 2504 Update(Layer self, Layer method_layer, Layer result_layer, char ** options=None, GDALProgressFunc callback=0, void * callback_data=None) -> OGRErr 2505 2506 OGRErr OGR_L_Update(OGRLayerH 2507 pLayerInput, OGRLayerH pLayerMethod, OGRLayerH pLayerResult, char 2508 **papszOptions, GDALProgressFunc pfnProgress, void *pProgressArg) 2509 2510 Update this layer with features from the update layer. 2511 2512 The result layer contains features whose geometries represent areas 2513 that are either in the input layer or in the method layer. The 2514 features in the result layer have areas of the features of the method 2515 layer or those ares of the features of the input layer that are not 2516 covered by the method layer. The features of the result layer get 2517 their attributes from the input layer. The schema of the result layer 2518 can be set by the user or, if it is empty, is initialized to contain 2519 all fields in the input layer. 2520 2521 If the schema of the result is set by user and contains fields that 2522 have the same name as a field in the method layer, then the attribute 2523 in the result feature the originates from the method layer will get 2524 the value from the feature of the method layer. 2525 2526 For best performance use the minimum amount of features in the method 2527 layer and copy it into a memory layer. 2528 2529 This method relies on GEOS support. Do not use unless the GEOS support 2530 is compiled in. The recognized list of options is : 2531 SKIP_FAILURES=YES/NO. Set it to YES to go on, even when a feature 2532 could not be inserted or a GEOS call failed. 2533 2534 PROMOTE_TO_MULTI=YES/NO. Set it to YES to convert Polygons into 2535 MultiPolygons, or LineStrings to MultiLineStrings. 2536 2537 INPUT_PREFIX=string. Set a prefix for the field names that will be 2538 created from the fields of the input layer. 2539 2540 METHOD_PREFIX=string. Set a prefix for the field names that will be 2541 created from the fields of the method layer. 2542 2543 This function is the same as the C++ method OGRLayer::Update(). 2544 2545 Parameters: 2546 ----------- 2547 2548 pLayerInput: the input layer. Should not be NULL. 2549 2550 pLayerMethod: the method layer. Should not be NULL. 2551 2552 pLayerResult: the layer where the features resulting from the 2553 operation are inserted. Should not be NULL. See above the note about 2554 the schema. 2555 2556 papszOptions: NULL terminated list of options (may be NULL). 2557 2558 pfnProgress: a GDALProgressFunc() compatible callback function for 2559 reporting progress or NULL. 2560 2561 pProgressArg: argument to be passed to pfnProgress. May be NULL. 2562 2563 an error code if there was an error or the execution was interrupted, 2564 OGRERR_NONE otherwise. 2565 2566 The first geometry field is always used. 2567 2568 OGR 1.10 2569 """ 2570 return _ogr.Layer_Update(self, *args, **kwargs)
2571 2572
2573 - def Clip(self, *args, **kwargs):
2574 """ 2575 Clip(Layer self, Layer method_layer, Layer result_layer, char ** options=None, GDALProgressFunc callback=0, void * callback_data=None) -> OGRErr 2576 2577 OGRErr OGR_L_Clip(OGRLayerH pLayerInput, 2578 OGRLayerH pLayerMethod, OGRLayerH pLayerResult, char **papszOptions, 2579 GDALProgressFunc pfnProgress, void *pProgressArg) 2580 2581 Clip off areas that are not covered by the method layer. 2582 2583 The result layer contains features whose geometries represent areas 2584 that are in the input layer and in the method layer. The features in 2585 the result layer have the (possibly clipped) areas of features in the 2586 input layer and the attributes from the same features. The schema of 2587 the result layer can be set by the user or, if it is empty, is 2588 initialized to contain all fields in the input layer. 2589 2590 For best performance use the minimum amount of features in the method 2591 layer and copy it into a memory layer. 2592 2593 This method relies on GEOS support. Do not use unless the GEOS support 2594 is compiled in. The recognized list of options is : 2595 SKIP_FAILURES=YES/NO. Set it to YES to go on, even when a feature 2596 could not be inserted or a GEOS call failed. 2597 2598 PROMOTE_TO_MULTI=YES/NO. Set it to YES to convert Polygons into 2599 MultiPolygons, or LineStrings to MultiLineStrings. 2600 2601 INPUT_PREFIX=string. Set a prefix for the field names that will be 2602 created from the fields of the input layer. 2603 2604 METHOD_PREFIX=string. Set a prefix for the field names that will be 2605 created from the fields of the method layer. 2606 2607 This function is the same as the C++ method OGRLayer::Clip(). 2608 2609 Parameters: 2610 ----------- 2611 2612 pLayerInput: the input layer. Should not be NULL. 2613 2614 pLayerMethod: the method layer. Should not be NULL. 2615 2616 pLayerResult: the layer where the features resulting from the 2617 operation are inserted. Should not be NULL. See above the note about 2618 the schema. 2619 2620 papszOptions: NULL terminated list of options (may be NULL). 2621 2622 pfnProgress: a GDALProgressFunc() compatible callback function for 2623 reporting progress or NULL. 2624 2625 pProgressArg: argument to be passed to pfnProgress. May be NULL. 2626 2627 an error code if there was an error or the execution was interrupted, 2628 OGRERR_NONE otherwise. 2629 2630 The first geometry field is always used. 2631 2632 OGR 1.10 2633 """ 2634 return _ogr.Layer_Clip(self, *args, **kwargs)
2635 2636
2637 - def Erase(self, *args, **kwargs):
2638 """ 2639 Erase(Layer self, Layer method_layer, Layer result_layer, char ** options=None, GDALProgressFunc callback=0, void * callback_data=None) -> OGRErr 2640 2641 OGRErr OGR_L_Erase(OGRLayerH 2642 pLayerInput, OGRLayerH pLayerMethod, OGRLayerH pLayerResult, char 2643 **papszOptions, GDALProgressFunc pfnProgress, void *pProgressArg) 2644 2645 Remove areas that are covered by the method layer. 2646 2647 The result layer contains features whose geometries represent areas 2648 that are in the input layer but not in the method layer. The features 2649 in the result layer have attributes from the input layer. The schema 2650 of the result layer can be set by the user or, if it is empty, is 2651 initialized to contain all fields in the input layer. 2652 2653 For best performance use the minimum amount of features in the method 2654 layer and copy it into a memory layer. 2655 2656 This method relies on GEOS support. Do not use unless the GEOS support 2657 is compiled in. The recognized list of options is : 2658 SKIP_FAILURES=YES/NO. Set it to YES to go on, even when a feature 2659 could not be inserted or a GEOS call failed. 2660 2661 PROMOTE_TO_MULTI=YES/NO. Set it to YES to convert Polygons into 2662 MultiPolygons, or LineStrings to MultiLineStrings. 2663 2664 INPUT_PREFIX=string. Set a prefix for the field names that will be 2665 created from the fields of the input layer. 2666 2667 METHOD_PREFIX=string. Set a prefix for the field names that will be 2668 created from the fields of the method layer. 2669 2670 This function is the same as the C++ method OGRLayer::Erase(). 2671 2672 Parameters: 2673 ----------- 2674 2675 pLayerInput: the input layer. Should not be NULL. 2676 2677 pLayerMethod: the method layer. Should not be NULL. 2678 2679 pLayerResult: the layer where the features resulting from the 2680 operation are inserted. Should not be NULL. See above the note about 2681 the schema. 2682 2683 papszOptions: NULL terminated list of options (may be NULL). 2684 2685 pfnProgress: a GDALProgressFunc() compatible callback function for 2686 reporting progress or NULL. 2687 2688 pProgressArg: argument to be passed to pfnProgress. May be NULL. 2689 2690 an error code if there was an error or the execution was interrupted, 2691 OGRERR_NONE otherwise. 2692 2693 The first geometry field is always used. 2694 2695 OGR 1.10 2696 """ 2697 return _ogr.Layer_Erase(self, *args, **kwargs)
2698 2699
2700 - def GetStyleTable(self, *args):
2701 """ 2702 GetStyleTable(Layer self) -> StyleTable 2703 2704 OGRStyleTableH 2705 OGR_L_GetStyleTable(OGRLayerH hLayer) 2706 2707 Get style table. 2708 """ 2709 return _ogr.Layer_GetStyleTable(self, *args)
2710 2711
2712 - def SetStyleTable(self, *args):
2713 """ 2714 SetStyleTable(Layer self, StyleTable table) 2715 2716 void 2717 OGR_L_SetStyleTable(OGRLayerH hLayer, OGRStyleTableH hStyleTable) 2718 2719 Set style table. 2720 """ 2721 return _ogr.Layer_SetStyleTable(self, *args)
2722 2723
2724 - def Reference(self):
2725 "For backwards compatibility only." 2726 pass
2727
2728 - def Dereference(self):
2729 "For backwards compatibility only." 2730 pass
2731
2732 - def __len__(self):
2733 """Returns the number of features in the layer""" 2734 return self.GetFeatureCount()
2735 2736 # To avoid __len__ being called when testing boolean value 2737 # which can have side effects (#4758)
2738 - def __nonzero__(self):
2739 return True
2740 2741 # For Python 3 compat 2742 __bool__ = __nonzero__ 2743
2744 - def __getitem__(self, value):
2745 """Support list and slice -like access to the layer. 2746 layer[0] would return the first feature on the layer. 2747 layer[0:4] would return a list of the first four features.""" 2748 if isinstance(value, slice): 2749 import sys 2750 output = [] 2751 if value.stop == sys.maxint: 2752 #for an unending slice, sys.maxint is used 2753 #We need to stop before that or GDAL will write an 2754 ##error to stdout 2755 stop = len(self) - 1 2756 else: 2757 stop = value.stop 2758 for i in xrange(value.start, stop, value.step): 2759 feature = self.GetFeature(i) 2760 if feature: 2761 output.append(feature) 2762 else: 2763 return output 2764 return output 2765 if isinstance(value, int): 2766 if value > len(self) - 1: 2767 raise IndexError 2768 return self.GetFeature(value) 2769 else: 2770 raise TypeError("Input %s is not of IntType or SliceType" % type(value))
2771
2772 - def CreateFields(self, fields):
2773 """Create a list of fields on the Layer""" 2774 for i in fields: 2775 self.CreateField(i)
2776
2777 - def __iter__(self):
2778 self.ResetReading() 2779 while True: 2780 feature = self.GetNextFeature() 2781 if not feature: 2782 break 2783 yield feature
2784
2785 - def schema(self):
2786 output = [] 2787 defn = self.GetLayerDefn() 2788 for n in range(defn.GetFieldCount()): 2789 output.append(defn.GetFieldDefn(n)) 2790 return output
2791 schema = property(schema)
2792 2793 2794 Layer_swigregister = _ogr.Layer_swigregister 2795 Layer_swigregister(Layer) 2796
2797 -class Feature(_object):
2798 """Proxy of C++ OGRFeatureShadow class.""" 2799 2800 __swig_setmethods__ = {} 2801 __setattr__ = lambda self, name, value: _swig_setattr(self, Feature, name, value) 2802 __swig_getmethods__ = {} 2803 __getattr__ = lambda self, name: _swig_getattr(self, Feature, name) 2804 __repr__ = _swig_repr 2805 __swig_destroy__ = _ogr.delete_Feature 2806 __del__ = lambda self: None 2807
2808 - def __init__(self, *args, **kwargs):
2809 """__init__(OGRFeatureShadow self, FeatureDefn feature_def) -> Feature""" 2810 this = _ogr.new_Feature(*args, **kwargs) 2811 try: 2812 self.this.append(this) 2813 except __builtin__.Exception: 2814 self.this = this
2815
2816 - def GetDefnRef(self, *args):
2817 """ 2818 GetDefnRef(Feature self) -> FeatureDefn 2819 2820 OGRFeatureDefnH 2821 OGR_F_GetDefnRef(OGRFeatureH hFeat) 2822 2823 Fetch feature definition. 2824 2825 This function is the same as the C++ method OGRFeature::GetDefnRef(). 2826 2827 Parameters: 2828 ----------- 2829 2830 hFeat: handle to the feature to get the feature definition from. 2831 2832 a handle to the feature definition object on which feature depends. 2833 2834 """ 2835 return _ogr.Feature_GetDefnRef(self, *args)
2836 2837
2838 - def SetGeometry(self, *args):
2839 """ 2840 SetGeometry(Feature self, Geometry geom) -> OGRErr 2841 2842 OGRErr 2843 OGR_F_SetGeometry(OGRFeatureH hFeat, OGRGeometryH hGeom) 2844 2845 Set feature geometry. 2846 2847 This function updates the features geometry, and operate exactly as 2848 SetGeometryDirectly(), except that this function does not assume 2849 ownership of the passed geometry, but instead makes a copy of it. 2850 2851 This function is the same as the C++ OGRFeature::SetGeometry(). 2852 2853 This method has only an effect on the in-memory feature object. If 2854 this object comes from a layer and the modifications must be 2855 serialized back to the datasource, OGR_L_SetFeature() must be used 2856 afterwards. Or if this is a new feature, OGR_L_CreateFeature() must be 2857 used afterwards. 2858 2859 Parameters: 2860 ----------- 2861 2862 hFeat: handle to the feature on which new geometry is applied to. 2863 2864 hGeom: handle to the new geometry to apply to feature. 2865 2866 OGRERR_NONE if successful, or OGR_UNSUPPORTED_GEOMETRY_TYPE if the 2867 geometry type is illegal for the OGRFeatureDefn (checking not yet 2868 implemented). 2869 """ 2870 return _ogr.Feature_SetGeometry(self, *args)
2871 2872
2873 - def SetGeometryDirectly(self, *args):
2874 """ 2875 SetGeometryDirectly(Feature self, Geometry geom) -> OGRErr 2876 2877 OGRErr 2878 OGR_F_SetGeometryDirectly(OGRFeatureH hFeat, OGRGeometryH hGeom) 2879 2880 Set feature geometry. 2881 2882 This function updates the features geometry, and operate exactly as 2883 SetGeometry(), except that this function assumes ownership of the 2884 passed geometry (even in case of failure of that function). 2885 2886 This function is the same as the C++ method 2887 OGRFeature::SetGeometryDirectly. 2888 2889 This method has only an effect on the in-memory feature object. If 2890 this object comes from a layer and the modifications must be 2891 serialized back to the datasource, OGR_L_SetFeature() must be used 2892 afterwards. Or if this is a new feature, OGR_L_CreateFeature() must be 2893 used afterwards. 2894 2895 Parameters: 2896 ----------- 2897 2898 hFeat: handle to the feature on which to apply the geometry. 2899 2900 hGeom: handle to the new geometry to apply to feature. 2901 2902 OGRERR_NONE if successful, or OGR_UNSUPPORTED_GEOMETRY_TYPE if the 2903 geometry type is illegal for the OGRFeatureDefn (checking not yet 2904 implemented). 2905 """ 2906 return _ogr.Feature_SetGeometryDirectly(self, *args)
2907 2908
2909 - def GetGeometryRef(self, *args):
2910 """ 2911 GetGeometryRef(Feature self) -> Geometry 2912 2913 OGRGeometryH 2914 OGR_F_GetGeometryRef(OGRFeatureH hFeat) 2915 2916 Fetch a handle to feature geometry. 2917 2918 This function is essentially the same as the C++ method 2919 OGRFeature::GetGeometryRef() (the only difference is that this C 2920 function honours OGRGetNonLinearGeometriesEnabledFlag()) 2921 2922 Parameters: 2923 ----------- 2924 2925 hFeat: handle to the feature to get geometry from. 2926 2927 a handle to internal feature geometry. This object should not be 2928 modified. 2929 """ 2930 return _ogr.Feature_GetGeometryRef(self, *args)
2931 2932
2933 - def SetGeomField(self, *args):
2934 """ 2935 SetGeomField(Feature self, int iField, Geometry geom) -> OGRErr 2936 SetGeomField(Feature self, char const * field_name, Geometry geom) -> OGRErr 2937 2938 OGRErr 2939 OGR_F_SetGeomField(OGRFeatureH hFeat, int iField, OGRGeometryH hGeom) 2940 2941 Set feature geometry of a specified geometry field. 2942 2943 This function updates the features geometry, and operate exactly as 2944 SetGeometryDirectly(), except that this function does not assume 2945 ownership of the passed geometry, but instead makes a copy of it. 2946 2947 This function is the same as the C++ OGRFeature::SetGeomField(). 2948 2949 Parameters: 2950 ----------- 2951 2952 hFeat: handle to the feature on which new geometry is applied to. 2953 2954 iField: geometry field to set. 2955 2956 hGeom: handle to the new geometry to apply to feature. 2957 2958 OGRERR_NONE if successful, or OGR_UNSUPPORTED_GEOMETRY_TYPE if the 2959 geometry type is illegal for the OGRFeatureDefn (checking not yet 2960 implemented). 2961 """ 2962 return _ogr.Feature_SetGeomField(self, *args)
2963 2964
2965 - def SetGeomFieldDirectly(self, *args):
2966 """ 2967 SetGeomFieldDirectly(Feature self, int iField, Geometry geom) -> OGRErr 2968 SetGeomFieldDirectly(Feature self, char const * field_name, Geometry geom) -> OGRErr 2969 2970 OGRErr 2971 OGR_F_SetGeomFieldDirectly(OGRFeatureH hFeat, int iField, OGRGeometryH 2972 hGeom) 2973 2974 Set feature geometry of a specified geometry field. 2975 2976 This function updates the features geometry, and operate exactly as 2977 SetGeomField(), except that this function assumes ownership of the 2978 passed geometry (even in case of failure of that function). 2979 2980 This function is the same as the C++ method 2981 OGRFeature::SetGeomFieldDirectly. 2982 2983 Parameters: 2984 ----------- 2985 2986 hFeat: handle to the feature on which to apply the geometry. 2987 2988 iField: geometry field to set. 2989 2990 hGeom: handle to the new geometry to apply to feature. 2991 2992 OGRERR_NONE if successful, or OGRERR_FAILURE if the index is invalid, 2993 or OGR_UNSUPPORTED_GEOMETRY_TYPE if the geometry type is illegal for 2994 the OGRFeatureDefn (checking not yet implemented). 2995 2996 GDAL 1.11 2997 """ 2998 return _ogr.Feature_SetGeomFieldDirectly(self, *args)
2999 3000
3001 - def GetGeomFieldRef(self, *args):
3002 """ 3003 GetGeomFieldRef(Feature self, int iField) -> Geometry 3004 GetGeomFieldRef(Feature self, char const * field_name) -> Geometry 3005 3006 OGRGeometryH 3007 OGR_F_GetGeomFieldRef(OGRFeatureH hFeat, int iField) 3008 3009 Fetch a handle to feature geometry. 3010 3011 This function is the same as the C++ method 3012 OGRFeature::GetGeomFieldRef(). 3013 3014 Parameters: 3015 ----------- 3016 3017 hFeat: handle to the feature to get geometry from. 3018 3019 iField: geometry field to get. 3020 3021 a handle to internal feature geometry. This object should not be 3022 modified. 3023 3024 GDAL 1.11 3025 """ 3026 return _ogr.Feature_GetGeomFieldRef(self, *args)
3027 3028
3029 - def Clone(self, *args):
3030 """ 3031 Clone(Feature self) -> Feature 3032 3033 OGRFeatureH OGR_F_Clone(OGRFeatureH 3034 hFeat) 3035 3036 Duplicate feature. 3037 3038 The newly created feature is owned by the caller, and will have its 3039 own reference to the OGRFeatureDefn. 3040 3041 This function is the same as the C++ method OGRFeature::Clone(). 3042 3043 Parameters: 3044 ----------- 3045 3046 hFeat: handle to the feature to clone. 3047 3048 a handle to the new feature, exactly matching this feature. 3049 """ 3050 return _ogr.Feature_Clone(self, *args)
3051 3052
3053 - def Equal(self, *args):
3054 """ 3055 Equal(Feature self, Feature feature) -> bool 3056 3057 int OGR_F_Equal(OGRFeatureH hFeat, 3058 OGRFeatureH hOtherFeat) 3059 3060 Test if two features are the same. 3061 3062 Two features are considered equal if the share them (handle equality) 3063 same OGRFeatureDefn, have the same field values, and the same geometry 3064 (as tested by OGR_G_Equal()) as well as the same feature id. 3065 3066 This function is the same as the C++ method OGRFeature::Equal(). 3067 3068 Parameters: 3069 ----------- 3070 3071 hFeat: handle to one of the feature. 3072 3073 hOtherFeat: handle to the other feature to test this one against. 3074 3075 TRUE if they are equal, otherwise FALSE. 3076 """ 3077 return _ogr.Feature_Equal(self, *args)
3078 3079
3080 - def GetFieldCount(self, *args):
3081 """ 3082 GetFieldCount(Feature self) -> int 3083 3084 int 3085 OGR_F_GetFieldCount(OGRFeatureH hFeat) 3086 3087 Fetch number of fields on this feature This will always be the same as 3088 the field count for the OGRFeatureDefn. 3089 3090 This function is the same as the C++ method 3091 OGRFeature::GetFieldCount(). 3092 3093 Parameters: 3094 ----------- 3095 3096 hFeat: handle to the feature to get the fields count from. 3097 3098 count of fields. 3099 """ 3100 return _ogr.Feature_GetFieldCount(self, *args)
3101 3102
3103 - def GetFieldDefnRef(self, *args):
3104 """ 3105 GetFieldDefnRef(Feature self, int id) -> FieldDefn 3106 GetFieldDefnRef(Feature self, char const * field_name) -> FieldDefn 3107 3108 OGRFieldDefnH 3109 OGR_F_GetFieldDefnRef(OGRFeatureH hFeat, int i) 3110 3111 Fetch definition for this field. 3112 3113 This function is the same as the C++ method 3114 OGRFeature::GetFieldDefnRef(). 3115 3116 Parameters: 3117 ----------- 3118 3119 hFeat: handle to the feature on which the field is found. 3120 3121 i: the field to fetch, from 0 to GetFieldCount()-1. 3122 3123 a handle to the field definition (from the OGRFeatureDefn). This is 3124 an internal reference, and should not be deleted or modified. 3125 """ 3126 return _ogr.Feature_GetFieldDefnRef(self, *args)
3127 3128
3129 - def GetGeomFieldCount(self, *args):
3130 """ 3131 GetGeomFieldCount(Feature self) -> int 3132 3133 int 3134 OGR_F_GetGeomFieldCount(OGRFeatureH hFeat) 3135 3136 Fetch number of geometry fields on this feature This will always be 3137 the same as the geometry field count for the OGRFeatureDefn. 3138 3139 This function is the same as the C++ method 3140 OGRFeature::GetGeomFieldCount(). 3141 3142 Parameters: 3143 ----------- 3144 3145 hFeat: handle to the feature to get the geometry fields count from. 3146 3147 count of geometry fields. 3148 3149 GDAL 1.11 3150 """ 3151 return _ogr.Feature_GetGeomFieldCount(self, *args)
3152 3153
3154 - def GetGeomFieldDefnRef(self, *args):
3155 """ 3156 GetGeomFieldDefnRef(Feature self, int id) -> GeomFieldDefn 3157 GetGeomFieldDefnRef(Feature self, char const * field_name) -> GeomFieldDefn 3158 3159 OGRGeomFieldDefnH 3160 OGR_F_GetGeomFieldDefnRef(OGRFeatureH hFeat, int i) 3161 3162 Fetch definition for this geometry field. 3163 3164 This function is the same as the C++ method 3165 OGRFeature::GetGeomFieldDefnRef(). 3166 3167 Parameters: 3168 ----------- 3169 3170 hFeat: handle to the feature on which the field is found. 3171 3172 i: the field to fetch, from 0 to GetGeomFieldCount()-1. 3173 3174 a handle to the field definition (from the OGRFeatureDefn). This is 3175 an internal reference, and should not be deleted or modified. 3176 3177 GDAL 1.11 3178 """ 3179 return _ogr.Feature_GetGeomFieldDefnRef(self, *args)
3180 3181
3182 - def GetFieldAsString(self, *args):
3183 """ 3184 GetFieldAsString(Feature self, int id) -> char const 3185 GetFieldAsString(Feature self, char const * field_name) -> char const * 3186 3187 const char* 3188 OGR_F_GetFieldAsString(OGRFeatureH hFeat, int iField) 3189 3190 Fetch field value as a string. 3191 3192 OFTReal and OFTInteger fields will be translated to string using 3193 sprintf(), but not necessarily using the established formatting rules. 3194 Other field types, or errors will result in a return value of zero. 3195 3196 This function is the same as the C++ method 3197 OGRFeature::GetFieldAsString(). 3198 3199 Parameters: 3200 ----------- 3201 3202 hFeat: handle to the feature that owned the field. 3203 3204 iField: the field to fetch, from 0 to GetFieldCount()-1. 3205 3206 the field value. This string is internal, and should not be modified, 3207 or freed. Its lifetime may be very brief. 3208 """ 3209 return _ogr.Feature_GetFieldAsString(self, *args)
3210 3211
3212 - def GetFieldAsInteger(self, *args):
3213 """ 3214 GetFieldAsInteger(Feature self, int id) -> int 3215 GetFieldAsInteger(Feature self, char const * field_name) -> int 3216 3217 int 3218 OGR_F_GetFieldAsInteger(OGRFeatureH hFeat, int iField) 3219 3220 Fetch field value as integer. 3221 3222 OFTString features will be translated using atoi(). OFTReal fields 3223 will be cast to integer. Other field types, or errors will result in a 3224 return value of zero. 3225 3226 This function is the same as the C++ method 3227 OGRFeature::GetFieldAsInteger(). 3228 3229 Parameters: 3230 ----------- 3231 3232 hFeat: handle to the feature that owned the field. 3233 3234 iField: the field to fetch, from 0 to GetFieldCount()-1. 3235 3236 the field value. 3237 """ 3238 return _ogr.Feature_GetFieldAsInteger(self, *args)
3239 3240
3241 - def GetFieldAsInteger64(self, *args):
3242 """ 3243 GetFieldAsInteger64(Feature self, int id) -> GIntBig 3244 GetFieldAsInteger64(Feature self, char const * field_name) -> GIntBig 3245 3246 GIntBig 3247 OGR_F_GetFieldAsInteger64(OGRFeatureH hFeat, int iField) 3248 3249 Fetch field value as integer 64 bit. 3250 3251 OFTInteger are promoted to 64 bit. OFTString features will be 3252 translated using CPLAtoGIntBig(). OFTReal fields will be cast to 3253 integer. Other field types, or errors will result in a return value of 3254 zero. 3255 3256 This function is the same as the C++ method 3257 OGRFeature::GetFieldAsInteger64(). 3258 3259 Parameters: 3260 ----------- 3261 3262 hFeat: handle to the feature that owned the field. 3263 3264 iField: the field to fetch, from 0 to GetFieldCount()-1. 3265 3266 the field value. 3267 3268 GDAL 2.0 3269 """ 3270 return _ogr.Feature_GetFieldAsInteger64(self, *args)
3271 3272
3273 - def GetFieldAsDouble(self, *args):
3274 """ 3275 GetFieldAsDouble(Feature self, int id) -> double 3276 GetFieldAsDouble(Feature self, char const * field_name) -> double 3277 3278 double 3279 OGR_F_GetFieldAsDouble(OGRFeatureH hFeat, int iField) 3280 3281 Fetch field value as a double. 3282 3283 OFTString features will be translated using CPLAtof(). OFTInteger 3284 fields will be cast to double. Other field types, or errors will 3285 result in a return value of zero. 3286 3287 This function is the same as the C++ method 3288 OGRFeature::GetFieldAsDouble(). 3289 3290 Parameters: 3291 ----------- 3292 3293 hFeat: handle to the feature that owned the field. 3294 3295 iField: the field to fetch, from 0 to GetFieldCount()-1. 3296 3297 the field value. 3298 """ 3299 return _ogr.Feature_GetFieldAsDouble(self, *args)
3300 3301
3302 - def GetFieldAsDateTime(self, *args):
3303 """ 3304 GetFieldAsDateTime(Feature self, int id) 3305 GetFieldAsDateTime(Feature self, char const * field_name) 3306 3307 int 3308 OGR_F_GetFieldAsDateTime(OGRFeatureH hFeat, int iField, int *pnYear, 3309 int *pnMonth, int *pnDay, int *pnHour, int *pnMinute, int *pnSecond, 3310 int *pnTZFlag) 3311 3312 Fetch field value as date and time. 3313 3314 Currently this method only works for OFTDate, OFTTime and OFTDateTime 3315 fields. 3316 3317 This function is the same as the C++ method 3318 OGRFeature::GetFieldAsDateTime(). 3319 3320 Parameters: 3321 ----------- 3322 3323 hFeat: handle to the feature that owned the field. 3324 3325 iField: the field to fetch, from 0 to GetFieldCount()-1. 3326 3327 pnYear: (including century) 3328 3329 pnMonth: (1-12) 3330 3331 pnDay: (1-31) 3332 3333 pnHour: (0-23) 3334 3335 pnMinute: (0-59) 3336 3337 pnSecond: (0-59) 3338 3339 pnTZFlag: (0=unknown, 1=localtime, 100=GMT, see data model for 3340 details) 3341 3342 TRUE on success or FALSE on failure. 3343 3344 See: Use OGR_F_GetFieldAsDateTimeEx() for second with millisecond 3345 accuracy. 3346 """ 3347 return _ogr.Feature_GetFieldAsDateTime(self, *args)
3348 3349
3350 - def GetFieldAsIntegerList(self, *args):
3351 """ 3352 GetFieldAsIntegerList(Feature self, int id) 3353 GetFieldAsIntegerList(Feature self, char const * field_name) 3354 3355 const int* 3356 OGR_F_GetFieldAsIntegerList(OGRFeatureH hFeat, int iField, int 3357 *pnCount) 3358 3359 Fetch field value as a list of integers. 3360 3361 Currently this function only works for OFTIntegerList fields. 3362 3363 This function is the same as the C++ method 3364 OGRFeature::GetFieldAsIntegerList(). 3365 3366 Parameters: 3367 ----------- 3368 3369 hFeat: handle to the feature that owned the field. 3370 3371 iField: the field to fetch, from 0 to GetFieldCount()-1. 3372 3373 pnCount: an integer to put the list count (number of integers) into. 3374 3375 the field value. This list is internal, and should not be modified, or 3376 freed. Its lifetime may be very brief. If *pnCount is zero on return 3377 the returned pointer may be NULL or non-NULL. 3378 """ 3379 return _ogr.Feature_GetFieldAsIntegerList(self, *args)
3380 3381
3382 - def GetFieldAsInteger64List(self, *args):
3383 """ 3384 GetFieldAsInteger64List(Feature self, int id) 3385 3386 const GIntBig* 3387 OGR_F_GetFieldAsInteger64List(OGRFeatureH hFeat, int iField, int 3388 *pnCount) 3389 3390 Fetch field value as a list of 64 bit integers. 3391 3392 Currently this function only works for OFTInteger64List fields. 3393 3394 This function is the same as the C++ method 3395 OGRFeature::GetFieldAsInteger64List(). 3396 3397 Parameters: 3398 ----------- 3399 3400 hFeat: handle to the feature that owned the field. 3401 3402 iField: the field to fetch, from 0 to GetFieldCount()-1. 3403 3404 pnCount: an integer to put the list count (number of integers) into. 3405 3406 the field value. This list is internal, and should not be modified, or 3407 freed. Its lifetime may be very brief. If *pnCount is zero on return 3408 the returned pointer may be NULL or non-NULL. 3409 3410 GDAL 2.0 3411 """ 3412 return _ogr.Feature_GetFieldAsInteger64List(self, *args)
3413 3414
3415 - def GetFieldAsDoubleList(self, *args):
3416 """ 3417 GetFieldAsDoubleList(Feature self, int id) 3418 GetFieldAsDoubleList(Feature self, char const * field_name) 3419 3420 const double* 3421 OGR_F_GetFieldAsDoubleList(OGRFeatureH hFeat, int iField, int 3422 *pnCount) 3423 3424 Fetch field value as a list of doubles. 3425 3426 Currently this function only works for OFTRealList fields. 3427 3428 This function is the same as the C++ method 3429 OGRFeature::GetFieldAsDoubleList(). 3430 3431 Parameters: 3432 ----------- 3433 3434 hFeat: handle to the feature that owned the field. 3435 3436 iField: the field to fetch, from 0 to GetFieldCount()-1. 3437 3438 pnCount: an integer to put the list count (number of doubles) into. 3439 3440 the field value. This list is internal, and should not be modified, or 3441 freed. Its lifetime may be very brief. If *pnCount is zero on return 3442 the returned pointer may be NULL or non-NULL. 3443 """ 3444 return _ogr.Feature_GetFieldAsDoubleList(self, *args)
3445 3446
3447 - def GetFieldAsStringList(self, *args):
3448 """ 3449 GetFieldAsStringList(Feature self, int id) -> char ** 3450 3451 char** 3452 OGR_F_GetFieldAsStringList(OGRFeatureH hFeat, int iField) 3453 3454 Fetch field value as a list of strings. 3455 3456 Currently this method only works for OFTStringList fields. 3457 3458 The returned list is terminated by a NULL pointer. The number of 3459 elements can also be calculated using CSLCount(). 3460 3461 This function is the same as the C++ method 3462 OGRFeature::GetFieldAsStringList(). 3463 3464 Parameters: 3465 ----------- 3466 3467 hFeat: handle to the feature that owned the field. 3468 3469 iField: the field to fetch, from 0 to GetFieldCount()-1. 3470 3471 the field value. This list is internal, and should not be modified, or 3472 freed. Its lifetime may be very brief. 3473 """ 3474 return _ogr.Feature_GetFieldAsStringList(self, *args)
3475 3476
3477 - def GetFieldAsBinary(self, *args):
3478 """ 3479 GetFieldAsBinary(Feature self, int id) -> OGRErr 3480 GetFieldAsBinary(Feature self, char const * field_name) -> OGRErr 3481 3482 GByte* 3483 OGR_F_GetFieldAsBinary(OGRFeatureH hFeat, int iField, int *pnBytes) 3484 3485 Fetch field value as binary. 3486 3487 This method only works for OFTBinary and OFTString fields. 3488 3489 This function is the same as the C++ method 3490 OGRFeature::GetFieldAsBinary(). 3491 3492 Parameters: 3493 ----------- 3494 3495 hFeat: handle to the feature that owned the field. 3496 3497 iField: the field to fetch, from 0 to GetFieldCount()-1. 3498 3499 pnBytes: location to place count of bytes returned. 3500 3501 the field value. This list is internal, and should not be modified, or 3502 freed. Its lifetime may be very brief. 3503 """ 3504 return _ogr.Feature_GetFieldAsBinary(self, *args)
3505 3506
3507 - def IsFieldSet(self, *args):
3508 """ 3509 IsFieldSet(Feature self, int id) -> bool 3510 IsFieldSet(Feature self, char const * field_name) -> bool 3511 3512 int OGR_F_IsFieldSet(OGRFeatureH 3513 hFeat, int iField) 3514 3515 Test if a field has ever been assigned a value or not. 3516 3517 This function is the same as the C++ method OGRFeature::IsFieldSet(). 3518 3519 Parameters: 3520 ----------- 3521 3522 hFeat: handle to the feature on which the field is. 3523 3524 iField: the field to test. 3525 3526 TRUE if the field has been set, otherwise false. 3527 """ 3528 return _ogr.Feature_IsFieldSet(self, *args)
3529 3530
3531 - def IsFieldNull(self, *args):
3532 """ 3533 IsFieldNull(Feature self, int id) -> bool 3534 IsFieldNull(Feature self, char const * field_name) -> bool 3535 3536 int OGR_F_IsFieldNull(OGRFeatureH 3537 hFeat, int iField) 3538 3539 Test if a field is null. 3540 3541 This function is the same as the C++ method OGRFeature::IsFieldNull(). 3542 3543 Parameters: 3544 ----------- 3545 3546 hFeat: handle to the feature on which the field is. 3547 3548 iField: the field to test. 3549 3550 TRUE if the field is null, otherwise false. 3551 3552 GDAL 2.2 3553 """ 3554 return _ogr.Feature_IsFieldNull(self, *args)
3555 3556
3557 - def IsFieldSetAndNotNull(self, *args):
3558 """ 3559 IsFieldSetAndNotNull(Feature self, int id) -> bool 3560 IsFieldSetAndNotNull(Feature self, char const * field_name) -> bool 3561 3562 int 3563 OGR_F_IsFieldSetAndNotNull(OGRFeatureH hFeat, int iField) 3564 3565 Test if a field is set and not null. 3566 3567 This function is the same as the C++ method 3568 OGRFeature::IsFieldSetAndNotNull(). 3569 3570 Parameters: 3571 ----------- 3572 3573 hFeat: handle to the feature on which the field is. 3574 3575 iField: the field to test. 3576 3577 TRUE if the field is set and not null, otherwise false. 3578 3579 GDAL 2.2 3580 """ 3581 return _ogr.Feature_IsFieldSetAndNotNull(self, *args)
3582 3583
3584 - def GetFieldIndex(self, *args):
3585 """ 3586 GetFieldIndex(Feature self, char const * field_name) -> int 3587 3588 int 3589 OGR_F_GetFieldIndex(OGRFeatureH hFeat, const char *pszName) 3590 3591 Fetch the field index given field name. 3592 3593 This is a cover for the OGRFeatureDefn::GetFieldIndex() method. 3594 3595 This function is the same as the C++ method 3596 OGRFeature::GetFieldIndex(). 3597 3598 Parameters: 3599 ----------- 3600 3601 hFeat: handle to the feature on which the field is found. 3602 3603 pszName: the name of the field to search for. 3604 3605 the field index, or -1 if no matching field is found. 3606 """ 3607 return _ogr.Feature_GetFieldIndex(self, *args)
3608 3609
3610 - def GetGeomFieldIndex(self, *args):
3611 """ 3612 GetGeomFieldIndex(Feature self, char const * field_name) -> int 3613 3614 int 3615 OGR_F_GetGeomFieldIndex(OGRFeatureH hFeat, const char *pszName) 3616 3617 Fetch the geometry field index given geometry field name. 3618 3619 This is a cover for the OGRFeatureDefn::GetGeomFieldIndex() method. 3620 3621 This function is the same as the C++ method 3622 OGRFeature::GetGeomFieldIndex(). 3623 3624 Parameters: 3625 ----------- 3626 3627 hFeat: handle to the feature on which the geometry field is found. 3628 3629 pszName: the name of the geometry field to search for. 3630 3631 the geometry field index, or -1 if no matching geometry field is 3632 found. 3633 3634 GDAL 1.11 3635 """ 3636 return _ogr.Feature_GetGeomFieldIndex(self, *args)
3637 3638
3639 - def GetFID(self, *args):
3640 """ 3641 GetFID(Feature self) -> GIntBig 3642 3643 GIntBig OGR_F_GetFID(OGRFeatureH 3644 hFeat) 3645 3646 Get feature identifier. 3647 3648 This function is the same as the C++ method OGRFeature::GetFID(). 3649 Note: since GDAL 2.0, this method returns a GIntBig (previously a 3650 long) 3651 3652 Parameters: 3653 ----------- 3654 3655 hFeat: handle to the feature from which to get the feature 3656 identifier. 3657 3658 feature id or OGRNullFID if none has been assigned. 3659 """ 3660 return _ogr.Feature_GetFID(self, *args)
3661 3662
3663 - def SetFID(self, *args):
3664 """ 3665 SetFID(Feature self, GIntBig fid) -> OGRErr 3666 3667 OGRErr OGR_F_SetFID(OGRFeatureH hFeat, 3668 GIntBig nFID) 3669 3670 Set the feature identifier. 3671 3672 For specific types of features this operation may fail on illegal 3673 features ids. Generally it always succeeds. Feature ids should be 3674 greater than or equal to zero, with the exception of OGRNullFID (-1) 3675 indicating that the feature id is unknown. 3676 3677 This function is the same as the C++ method OGRFeature::SetFID(). 3678 3679 Parameters: 3680 ----------- 3681 3682 hFeat: handle to the feature to set the feature id to. 3683 3684 nFID: the new feature identifier value to assign. 3685 3686 On success OGRERR_NONE, or on failure some other value. 3687 """ 3688 return _ogr.Feature_SetFID(self, *args)
3689 3690
3691 - def DumpReadable(self, *args):
3692 """ 3693 DumpReadable(Feature self) 3694 3695 void 3696 OGR_F_DumpReadable(OGRFeatureH hFeat, FILE *fpOut) 3697 3698 Dump this feature in a human readable form. 3699 3700 This dumps the attributes, and geometry; however, it doesn't 3701 definition information (other than field types and names), nor does it 3702 report the geometry spatial reference system. 3703 3704 This function is the same as the C++ method 3705 OGRFeature::DumpReadable(). 3706 3707 Parameters: 3708 ----------- 3709 3710 hFeat: handle to the feature to dump. 3711 3712 fpOut: the stream to write to, such as strout. 3713 """ 3714 return _ogr.Feature_DumpReadable(self, *args)
3715 3716
3717 - def UnsetField(self, *args):
3718 """ 3719 UnsetField(Feature self, int id) 3720 UnsetField(Feature self, char const * field_name) 3721 3722 void OGR_F_UnsetField(OGRFeatureH 3723 hFeat, int iField) 3724 3725 Clear a field, marking it as unset. 3726 3727 This function is the same as the C++ method OGRFeature::UnsetField(). 3728 3729 Parameters: 3730 ----------- 3731 3732 hFeat: handle to the feature on which the field is. 3733 3734 iField: the field to unset. 3735 """ 3736 return _ogr.Feature_UnsetField(self, *args)
3737 3738
3739 - def SetFieldNull(self, *args):
3740 """ 3741 SetFieldNull(Feature self, int id) 3742 SetFieldNull(Feature self, char const * field_name) 3743 3744 void 3745 OGR_F_SetFieldNull(OGRFeatureH hFeat, int iField) 3746 3747 Clear a field, marking it as null. 3748 3749 This function is the same as the C++ method 3750 OGRFeature::SetFieldNull(). 3751 3752 Parameters: 3753 ----------- 3754 3755 hFeat: handle to the feature on which the field is. 3756 3757 iField: the field to set to null. 3758 3759 GDAL 2.2 3760 """ 3761 return _ogr.Feature_SetFieldNull(self, *args)
3762 3763
3764 - def SetFieldInteger64(self, *args):
3765 """ 3766 SetFieldInteger64(Feature self, int id, GIntBig value) 3767 3768 void 3769 OGR_F_SetFieldInteger64(OGRFeatureH hFeat, int iField, GIntBig nValue) 3770 3771 Set field to 64 bit integer value. 3772 3773 OFTInteger, OFTInteger64 and OFTReal fields will be set directly. 3774 OFTString fields will be assigned a string representation of the 3775 value, but not necessarily taking into account formatting constraints 3776 on this field. Other field types may be unaffected. 3777 3778 This function is the same as the C++ method OGRFeature::SetField(). 3779 3780 This method has only an effect on the in-memory feature object. If 3781 this object comes from a layer and the modifications must be 3782 serialized back to the datasource, OGR_L_SetFeature() must be used 3783 afterwards. Or if this is a new feature, OGR_L_CreateFeature() must be 3784 used afterwards. 3785 3786 Parameters: 3787 ----------- 3788 3789 hFeat: handle to the feature that owned the field. 3790 3791 iField: the field to fetch, from 0 to GetFieldCount()-1. 3792 3793 nValue: the value to assign. 3794 3795 GDAL 2.0 3796 """ 3797 return _ogr.Feature_SetFieldInteger64(self, *args)
3798 3799
3800 - def SetField(self, *args):
3801 """ 3802 SetField(Feature self, int id, char const * value) 3803 SetField(Feature self, char const * field_name, char const * value) 3804 SetField(Feature self, int id, double value) 3805 SetField(Feature self, char const * field_name, double value) 3806 SetField(Feature self, int id, int year, int month, int day, int hour, int minute, float second, int tzflag) 3807 SetField(Feature self, char const * field_name, int year, int month, int day, int hour, int minute, float second, int tzflag) 3808 """ 3809 return _ogr.Feature_SetField(self, *args)
3810 3811
3812 - def SetFieldIntegerList(self, *args):
3813 """ 3814 SetFieldIntegerList(Feature self, int id, int nList) 3815 3816 void 3817 OGR_F_SetFieldIntegerList(OGRFeatureH hFeat, int iField, int nCount, 3818 const int *panValues) 3819 3820 Set field to list of integers value. 3821 3822 This function currently on has an effect of OFTIntegerList, 3823 OFTInteger64List and OFTRealList fields. 3824 3825 This function is the same as the C++ method OGRFeature::SetField(). 3826 3827 This method has only an effect on the in-memory feature object. If 3828 this object comes from a layer and the modifications must be 3829 serialized back to the datasource, OGR_L_SetFeature() must be used 3830 afterwards. Or if this is a new feature, OGR_L_CreateFeature() must be 3831 used afterwards. 3832 3833 Parameters: 3834 ----------- 3835 3836 hFeat: handle to the feature that owned the field. 3837 3838 iField: the field to set, from 0 to GetFieldCount()-1. 3839 3840 nCount: the number of values in the list being assigned. 3841 3842 panValues: the values to assign. 3843 """ 3844 return _ogr.Feature_SetFieldIntegerList(self, *args)
3845 3846
3847 - def SetFieldInteger64List(self, *args):
3848 """ 3849 SetFieldInteger64List(Feature self, int id, int nList) 3850 3851 void 3852 OGR_F_SetFieldInteger64List(OGRFeatureH hFeat, int iField, int nCount, 3853 const GIntBig *panValues) 3854 3855 Set field to list of 64 bit integers value. 3856 3857 This function currently on has an effect of OFTIntegerList, 3858 OFTInteger64List and OFTRealList fields. 3859 3860 This function is the same as the C++ method OGRFeature::SetField(). 3861 3862 This method has only an effect on the in-memory feature object. If 3863 this object comes from a layer and the modifications must be 3864 serialized back to the datasource, OGR_L_SetFeature() must be used 3865 afterwards. Or if this is a new feature, OGR_L_CreateFeature() must be 3866 used afterwards. 3867 3868 Parameters: 3869 ----------- 3870 3871 hFeat: handle to the feature that owned the field. 3872 3873 iField: the field to set, from 0 to GetFieldCount()-1. 3874 3875 nCount: the number of values in the list being assigned. 3876 3877 panValues: the values to assign. 3878 3879 GDAL 2.0 3880 """ 3881 return _ogr.Feature_SetFieldInteger64List(self, *args)
3882 3883
3884 - def SetFieldDoubleList(self, *args):
3885 """ 3886 SetFieldDoubleList(Feature self, int id, int nList) 3887 3888 void 3889 OGR_F_SetFieldDoubleList(OGRFeatureH hFeat, int iField, int nCount, 3890 const double *padfValues) 3891 3892 Set field to list of doubles value. 3893 3894 This function currently on has an effect of OFTIntegerList, 3895 OFTInteger64List, OFTRealList fields. 3896 3897 This function is the same as the C++ method OGRFeature::SetField(). 3898 3899 This method has only an effect on the in-memory feature object. If 3900 this object comes from a layer and the modifications must be 3901 serialized back to the datasource, OGR_L_SetFeature() must be used 3902 afterwards. Or if this is a new feature, OGR_L_CreateFeature() must be 3903 used afterwards. 3904 3905 Parameters: 3906 ----------- 3907 3908 hFeat: handle to the feature that owned the field. 3909 3910 iField: the field to set, from 0 to GetFieldCount()-1. 3911 3912 nCount: the number of values in the list being assigned. 3913 3914 padfValues: the values to assign. 3915 """ 3916 return _ogr.Feature_SetFieldDoubleList(self, *args)
3917 3918
3919 - def SetFieldStringList(self, *args):
3920 """ 3921 SetFieldStringList(Feature self, int id, char ** pList) 3922 3923 void 3924 OGR_F_SetFieldStringList(OGRFeatureH hFeat, int iField, CSLConstList 3925 papszValues) 3926 3927 Set field to list of strings value. 3928 3929 This function currently on has an effect of OFTStringList fields. 3930 3931 This function is the same as the C++ method OGRFeature::SetField(). 3932 3933 This method has only an effect on the in-memory feature object. If 3934 this object comes from a layer and the modifications must be 3935 serialized back to the datasource, OGR_L_SetFeature() must be used 3936 afterwards. Or if this is a new feature, OGR_L_CreateFeature() must be 3937 used afterwards. 3938 3939 Parameters: 3940 ----------- 3941 3942 hFeat: handle to the feature that owned the field. 3943 3944 iField: the field to set, from 0 to GetFieldCount()-1. 3945 3946 papszValues: the values to assign. List of NUL-terminated string, 3947 ending with a NULL pointer. 3948 """ 3949 return _ogr.Feature_SetFieldStringList(self, *args)
3950 3951
3952 - def SetFieldBinaryFromHexString(self, *args):
3953 """ 3954 SetFieldBinaryFromHexString(Feature self, int id, char const * pszValue) 3955 SetFieldBinaryFromHexString(Feature self, char const * field_name, char const * pszValue) 3956 """ 3957 return _ogr.Feature_SetFieldBinaryFromHexString(self, *args)
3958 3959
3960 - def SetFrom(self, *args, **kwargs):
3961 """ 3962 SetFrom(Feature self, Feature other, int forgiving=1) -> OGRErr 3963 3964 OGRErr OGR_F_SetFrom(OGRFeatureH 3965 hFeat, OGRFeatureH hOtherFeat, int bForgiving) 3966 3967 Set one feature from another. 3968 3969 Overwrite the contents of this feature from the geometry and 3970 attributes of another. The hOtherFeature does not need to have the 3971 same OGRFeatureDefn. Field values are copied by corresponding field 3972 names. Field types do not have to exactly match. OGR_F_SetField*() 3973 function conversion rules will be applied as needed. 3974 3975 This function is the same as the C++ method OGRFeature::SetFrom(). 3976 3977 Parameters: 3978 ----------- 3979 3980 hFeat: handle to the feature to set to. 3981 3982 hOtherFeat: handle to the feature from which geometry, and field 3983 values will be copied. 3984 3985 bForgiving: TRUE if the operation should continue despite lacking 3986 output fields matching some of the source fields. 3987 3988 OGRERR_NONE if the operation succeeds, even if some values are not 3989 transferred, otherwise an error code. 3990 """ 3991 return _ogr.Feature_SetFrom(self, *args, **kwargs)
3992 3993
3994 - def SetFromWithMap(self, *args):
3995 """ 3996 SetFromWithMap(Feature self, Feature other, int forgiving, int nList) -> OGRErr 3997 3998 OGRErr 3999 OGR_F_SetFromWithMap(OGRFeatureH hFeat, OGRFeatureH hOtherFeat, int 4000 bForgiving, const int *panMap) 4001 4002 Set one feature from another. 4003 4004 Overwrite the contents of this feature from the geometry and 4005 attributes of another. The hOtherFeature does not need to have the 4006 same OGRFeatureDefn. Field values are copied according to the provided 4007 indices map. Field types do not have to exactly match. 4008 OGR_F_SetField*() function conversion rules will be applied as needed. 4009 This is more efficient than OGR_F_SetFrom() in that this doesn't 4010 lookup the fields by their names. Particularly useful when the field 4011 names don't match. 4012 4013 This function is the same as the C++ method OGRFeature::SetFrom(). 4014 4015 Parameters: 4016 ----------- 4017 4018 hFeat: handle to the feature to set to. 4019 4020 hOtherFeat: handle to the feature from which geometry, and field 4021 values will be copied. 4022 4023 panMap: Array of the indices of the destination feature's fields 4024 stored at the corresponding index of the source feature's fields. A 4025 value of -1 should be used to ignore the source's field. The array 4026 should not be NULL and be as long as the number of fields in the 4027 source feature. 4028 4029 bForgiving: TRUE if the operation should continue despite lacking 4030 output fields matching some of the source fields. 4031 4032 OGRERR_NONE if the operation succeeds, even if some values are not 4033 transferred, otherwise an error code. 4034 """ 4035 return _ogr.Feature_SetFromWithMap(self, *args)
4036 4037
4038 - def GetStyleString(self, *args):
4039 """ 4040 GetStyleString(Feature self) -> char const * 4041 4042 const char* 4043 OGR_F_GetStyleString(OGRFeatureH hFeat) 4044 4045 Fetch style string for this feature. 4046 4047 Set the OGR Feature Style Specification for details on the format of 4048 this string, and ogr_featurestyle.h for services available to parse 4049 it. 4050 4051 This function is the same as the C++ method 4052 OGRFeature::GetStyleString(). 4053 4054 Parameters: 4055 ----------- 4056 4057 hFeat: handle to the feature to get the style from. 4058 4059 a reference to a representation in string format, or NULL if there 4060 isn't one. 4061 """ 4062 return _ogr.Feature_GetStyleString(self, *args)
4063 4064
4065 - def SetStyleString(self, *args):
4066 """ 4067 SetStyleString(Feature self, char const * the_string) 4068 4069 void 4070 OGR_F_SetStyleString(OGRFeatureH hFeat, const char *pszStyle) 4071 4072 Set feature style string. 4073 4074 This method operate exactly as OGR_F_SetStyleStringDirectly() except 4075 that it does not assume ownership of the passed string, but instead 4076 makes a copy of it. 4077 4078 This function is the same as the C++ method 4079 OGRFeature::SetStyleString(). 4080 4081 Parameters: 4082 ----------- 4083 4084 hFeat: handle to the feature to set style to. 4085 4086 pszStyle: the style string to apply to this feature, cannot be NULL. 4087 4088 """ 4089 return _ogr.Feature_SetStyleString(self, *args)
4090 4091
4092 - def GetFieldType(self, *args):
4093 """ 4094 GetFieldType(Feature self, int id) -> OGRFieldType 4095 GetFieldType(Feature self, char const * field_name) -> OGRFieldType 4096 """ 4097 return _ogr.Feature_GetFieldType(self, *args)
4098 4099
4100 - def Validate(self, *args):
4101 """ 4102 Validate(Feature self, int flags, int bEmitError=True) -> int 4103 4104 int OGR_F_Validate(OGRFeatureH 4105 hFeat, int nValidateFlags, int bEmitError) 4106 4107 Validate that a feature meets constraints of its schema. 4108 4109 The scope of test is specified with the nValidateFlags parameter. 4110 4111 Regarding OGR_F_VAL_WIDTH, the test is done assuming the string width 4112 must be interpreted as the number of UTF-8 characters. Some drivers 4113 might interpret the width as the number of bytes instead. So this test 4114 is rather conservative (if it fails, then it will fail for all 4115 interpretations). 4116 4117 This function is the same as the C++ method OGRFeature::Validate(). 4118 4119 Parameters: 4120 ----------- 4121 4122 hFeat: handle to the feature to validate. 4123 4124 nValidateFlags: OGR_F_VAL_ALL or combination of OGR_F_VAL_NULL, 4125 OGR_F_VAL_GEOM_TYPE, OGR_F_VAL_WIDTH and 4126 OGR_F_VAL_ALLOW_NULL_WHEN_DEFAULT with '|' operator 4127 4128 bEmitError: TRUE if a CPLError() must be emitted when a check fails 4129 4130 TRUE if all enabled validation tests pass. 4131 4132 GDAL 2.0 4133 """ 4134 return _ogr.Feature_Validate(self, *args)
4135 4136
4137 - def FillUnsetWithDefault(self, *args):
4138 """ 4139 FillUnsetWithDefault(Feature self, int bNotNullableOnly=False, char ** options=None) 4140 4141 void 4142 OGR_F_FillUnsetWithDefault(OGRFeatureH hFeat, int bNotNullableOnly, 4143 char **papszOptions) 4144 4145 Fill unset fields with default values that might be defined. 4146 4147 This function is the same as the C++ method 4148 OGRFeature::FillUnsetWithDefault(). 4149 4150 Parameters: 4151 ----------- 4152 4153 hFeat: handle to the feature. 4154 4155 bNotNullableOnly: if we should fill only unset fields with a not-null 4156 constraint. 4157 4158 papszOptions: unused currently. Must be set to NULL. 4159 4160 GDAL 2.0 4161 """ 4162 return _ogr.Feature_FillUnsetWithDefault(self, *args)
4163 4164
4165 - def GetNativeData(self, *args):
4166 """ 4167 GetNativeData(Feature self) -> char const * 4168 4169 const char* 4170 OGR_F_GetNativeData(OGRFeatureH hFeat) 4171 4172 Returns the native data for the feature. 4173 4174 The native data is the representation in a "natural" form that comes 4175 from the driver that created this feature, or that is aimed at an 4176 output driver. The native data may be in different format, which is 4177 indicated by OGR_F_GetNativeMediaType(). 4178 4179 Note that most drivers do not support storing the native data in the 4180 feature object, and if they do, generally the NATIVE_DATA open option 4181 must be passed at dataset opening. 4182 4183 The "native data" does not imply it is something more performant or 4184 powerful than what can be obtained with the rest of the API, but it 4185 may be useful in round-tripping scenarios where some characteristics 4186 of the underlying format are not captured otherwise by the OGR 4187 abstraction. 4188 4189 This function is the same as the C++ method 4190 OGRFeature::GetNativeData(). 4191 4192 Parameters: 4193 ----------- 4194 4195 hFeat: handle to the feature. 4196 4197 a string with the native data, or NULL if there is none. 4198 4199 GDAL 2.1 4200 4201 See: 4202 https://trac.osgeo.org/gdal/wiki/rfc60_improved_roundtripping_in_ogr 4203 4204 """ 4205 return _ogr.Feature_GetNativeData(self, *args)
4206 4207
4208 - def GetNativeMediaType(self, *args):
4209 """ 4210 GetNativeMediaType(Feature self) -> char const * 4211 4212 const char* 4213 OGR_F_GetNativeMediaType(OGRFeatureH hFeat) 4214 4215 Returns the native media type for the feature. 4216 4217 The native media type is the identifier for the format of the native 4218 data. It follows the IANA RFC 2045 4219 (seehttps://en.wikipedia.org/wiki/Media_type), e.g. 4220 "application/vnd.geo+json" for JSon. 4221 4222 This function is the same as the C function 4223 OGR_F_GetNativeMediaType(). 4224 4225 Parameters: 4226 ----------- 4227 4228 hFeat: handle to the feature. 4229 4230 a string with the native media type, or NULL if there is none. 4231 4232 GDAL 2.1 4233 4234 See: 4235 https://trac.osgeo.org/gdal/wiki/rfc60_improved_roundtripping_in_ogr 4236 4237 """ 4238 return _ogr.Feature_GetNativeMediaType(self, *args)
4239 4240
4241 - def SetNativeData(self, *args):
4242 """ 4243 SetNativeData(Feature self, char const * nativeData) 4244 4245 void 4246 OGR_F_SetNativeData(OGRFeatureH hFeat, const char *pszNativeData) 4247 4248 Sets the native data for the feature. 4249 4250 The native data is the representation in a "natural" form that comes 4251 from the driver that created this feature, or that is aimed at an 4252 output driver. The native data may be in different format, which is 4253 indicated by OGR_F_GetNativeMediaType(). 4254 4255 This function is the same as the C++ method 4256 OGRFeature::SetNativeData(). 4257 4258 Parameters: 4259 ----------- 4260 4261 hFeat: handle to the feature. 4262 4263 pszNativeData: a string with the native data, or NULL if there is 4264 none. 4265 4266 GDAL 2.1 4267 4268 See: 4269 https://trac.osgeo.org/gdal/wiki/rfc60_improved_roundtripping_in_ogr 4270 4271 """ 4272 return _ogr.Feature_SetNativeData(self, *args)
4273 4274
4275 - def SetNativeMediaType(self, *args):
4276 """ 4277 SetNativeMediaType(Feature self, char const * nativeMediaType) 4278 4279 void 4280 OGR_F_SetNativeMediaType(OGRFeatureH hFeat, const char 4281 *pszNativeMediaType) 4282 4283 Sets the native media type for the feature. 4284 4285 The native media type is the identifier for the format of the native 4286 data. It follows the IANA RFC 2045 4287 (seehttps://en.wikipedia.org/wiki/Media_type), e.g. 4288 "application/vnd.geo+json" for JSon. 4289 4290 This function is the same as the C++ method 4291 OGRFeature::SetNativeMediaType(). 4292 4293 Parameters: 4294 ----------- 4295 4296 hFeat: handle to the feature. 4297 4298 pszNativeMediaType: a string with the native media type, or NULL if 4299 there is none. 4300 4301 GDAL 2.1 4302 4303 See: 4304 https://trac.osgeo.org/gdal/wiki/rfc60_improved_roundtripping_in_ogr 4305 4306 """ 4307 return _ogr.Feature_SetNativeMediaType(self, *args)
4308 4309
4310 - def SetFieldString(self, *args):
4311 """ 4312 SetFieldString(Feature self, int id, char const * value) 4313 4314 void 4315 OGR_F_SetFieldString(OGRFeatureH hFeat, int iField, const char 4316 *pszValue) 4317 4318 Set field to string value. 4319 4320 OFTInteger fields will be set based on an atoi() conversion of the 4321 string. OFTInteger64 fields will be set based on an CPLAtoGIntBig() 4322 conversion of the string. OFTReal fields will be set based on an 4323 CPLAtof() conversion of the string. Other field types may be 4324 unaffected. 4325 4326 This function is the same as the C++ method OGRFeature::SetField(). 4327 4328 This method has only an effect on the in-memory feature object. If 4329 this object comes from a layer and the modifications must be 4330 serialized back to the datasource, OGR_L_SetFeature() must be used 4331 afterwards. Or if this is a new feature, OGR_L_CreateFeature() must be 4332 used afterwards. 4333 4334 Parameters: 4335 ----------- 4336 4337 hFeat: handle to the feature that owned the field. 4338 4339 iField: the field to fetch, from 0 to GetFieldCount()-1. 4340 4341 pszValue: the value to assign. 4342 """ 4343 return _ogr.Feature_SetFieldString(self, *args)
4344 4345
4346 - def Reference(self):
4347 pass
4348
4349 - def Dereference(self):
4350 pass
4351
4352 - def Destroy(self):
4353 "Once called, self has effectively been destroyed. Do not access. For backwards compatibility only" 4354 _ogr.delete_Feature(self) 4355 self.thisown = 0
4356
4357 - def __cmp__(self, other):
4358 """Compares a feature to another for equality""" 4359 return self.Equal(other)
4360
4361 - def __copy__(self):
4362 return self.Clone()
4363
4364 - def _getfieldindex(self, fieldname):
4365 case_insensitive_idx = -1 4366 fdefn = _ogr.Feature_GetDefnRef(self) 4367 for i in range(fdefn.GetFieldCount()): 4368 name = fdefn.GetFieldDefn(i).GetName() 4369 if name == fieldname: 4370 return i 4371 elif case_insensitive_idx < 0 and name.lower() == fieldname.lower(): 4372 case_insensitive_idx = i 4373 return case_insensitive_idx
4374 4375 # This makes it possible to fetch fields in the form "feature.area". 4376 # This has some risk of name collisions.
4377 - def __getattr__(self, key):
4378 """Returns the values of fields by the given name""" 4379 if key == 'this': 4380 return self.__dict__[key] 4381 4382 idx = self._getfieldindex(key) 4383 if idx < 0: 4384 idx = self.GetGeomFieldIndex(key) 4385 if idx < 0: 4386 raise AttributeError(key) 4387 else: 4388 return self.GetGeomFieldRef(idx) 4389 else: 4390 return self.GetField(idx)
4391 4392 # This makes it possible to set fields in the form "feature.area". 4393 # This has some risk of name collisions.
4394 - def __setattr__(self, key, value):
4395 """Set the values of fields by the given name""" 4396 if key == 'this' or key == 'thisown': 4397 self.__dict__[key] = value 4398 else: 4399 idx = self._getfieldindex(key) 4400 if idx != -1: 4401 self.SetField2(idx, value) 4402 else: 4403 idx = self.GetGeomFieldIndex(key) 4404 if idx != -1: 4405 self.SetGeomField(idx, value) 4406 else: 4407 self.__dict__[key] = value
4408 4409 # This makes it possible to fetch fields in the form "feature['area']".
4410 - def __getitem__(self, key):
4411 """Returns the values of fields by the given name / field_index""" 4412 if isinstance(key, (str, type(u''))): 4413 fld_index = self._getfieldindex(key) 4414 else: 4415 fld_index = key 4416 if key == self.GetFieldCount(): 4417 raise IndexError 4418 if fld_index < 0: 4419 if isinstance(key, (str, type(u''))): 4420 fld_index = self.GetGeomFieldIndex(key) 4421 if fld_index < 0: 4422 raise KeyError("Illegal field requested in GetField()") 4423 else: 4424 return self.GetGeomFieldRef(fld_index) 4425 else: 4426 return self.GetField(fld_index)
4427 4428 # This makes it possible to set fields in the form "feature['area'] = 123".
4429 - def __setitem__(self, key, value):
4430 """Returns the value of a field by field name / index""" 4431 if isinstance(key, (str, type(u''))): 4432 fld_index = self._getfieldindex(key) 4433 else: 4434 fld_index = key 4435 if key == self.GetFieldCount(): 4436 raise IndexError 4437 if fld_index < 0: 4438 if isinstance(key, (str, type(u''))): 4439 fld_index = self.GetGeomFieldIndex(key) 4440 if fld_index < 0: 4441 raise KeyError("Illegal field requested in SetField()") 4442 else: 4443 return self.SetGeomField(fld_index, value) 4444 else: 4445 return self.SetField2(fld_index, value)
4446
4447 - def GetField(self, fld_index):
4448 if isinstance(fld_index, (str, type(u''))): 4449 fld_index = self._getfieldindex(fld_index) 4450 if (fld_index < 0) or (fld_index > self.GetFieldCount()): 4451 raise KeyError("Illegal field requested in GetField()") 4452 if not (self.IsFieldSet(fld_index)) or self.IsFieldNull(fld_index): 4453 return None 4454 fld_type = self.GetFieldType(fld_index) 4455 if fld_type == OFTInteger: 4456 return self.GetFieldAsInteger(fld_index) 4457 if fld_type == OFTInteger64: 4458 return self.GetFieldAsInteger64(fld_index) 4459 if fld_type == OFTReal: 4460 return self.GetFieldAsDouble(fld_index) 4461 if fld_type == OFTStringList: 4462 return self.GetFieldAsStringList(fld_index) 4463 if fld_type == OFTIntegerList: 4464 return self.GetFieldAsIntegerList(fld_index) 4465 if fld_type == OFTInteger64List: 4466 return self.GetFieldAsInteger64List(fld_index) 4467 if fld_type == OFTRealList: 4468 return self.GetFieldAsDoubleList(fld_index) 4469 ## if fld_type == OFTDateTime or fld_type == OFTDate or fld_type == OFTTime: 4470 # return self.GetFieldAsDate(fld_index) 4471 # default to returning as a string. Should we add more types? 4472 try: 4473 return self.GetFieldAsString(fld_index) 4474 except: 4475 # For Python3 on non-UTF8 strings 4476 return self.GetFieldAsBinary(fld_index)
4477 4478 # With several override, SWIG cannot dispatch automatically unicode strings 4479 # to the right implementation, so we have to do it at hand
4480 - def SetField(self, *args):
4481 """ 4482 SetField(self, int id, char value) 4483 SetField(self, char name, char value) 4484 SetField(self, int id, int value) 4485 SetField(self, char name, int value) 4486 SetField(self, int id, double value) 4487 SetField(self, char name, double value) 4488 SetField(self, int id, int year, int month, int day, int hour, int minute, 4489 int second, int tzflag) 4490 SetField(self, char name, int year, int month, int day, int hour, 4491 int minute, int second, int tzflag) 4492 """ 4493 4494 if len(args) == 2 and args[1] is None: 4495 return _ogr.Feature_SetFieldNull(self, args[0]) 4496 4497 if len(args) == 2 and (type(args[1]) == type(1) or type(args[1]) == type(12345678901234)): 4498 fld_index = args[0] 4499 if isinstance(fld_index, str) or isinstance(fld_index, type(u'')): 4500 fld_index = self._getfieldindex(fld_index) 4501 return _ogr.Feature_SetFieldInteger64(self, fld_index, args[1]) 4502 4503 4504 if len(args) == 2 and isinstance(args[1], type(u'')): 4505 fld_index = args[0] 4506 if isinstance(fld_index, str) or isinstance(fld_index, type(u'')): 4507 fld_index = self._getfieldindex(fld_index) 4508 return _ogr.Feature_SetFieldString(self, fld_index, args[1]) 4509 4510 return _ogr.Feature_SetField(self, *args)
4511
4512 - def SetField2(self, fld_index, value):
4513 if isinstance(fld_index, str) or isinstance(fld_index, type(u'')): 4514 fld_index = self._getfieldindex(fld_index) 4515 if (fld_index < 0) or (fld_index > self.GetFieldCount()): 4516 raise KeyError("Illegal field requested in SetField2()") 4517 4518 if value is None: 4519 self.SetFieldNull(fld_index) 4520 return 4521 4522 if isinstance(value, list): 4523 if not value: 4524 self.SetFieldNull(fld_index) 4525 return 4526 if isinstance(value[0], type(1)) or isinstance(value[0], type(12345678901234)): 4527 self.SetFieldInteger64List(fld_index, value) 4528 return 4529 elif isinstance(value[0], float): 4530 self.SetFieldDoubleList(fld_index, value) 4531 return 4532 elif isinstance(value[0], str): 4533 self.SetFieldStringList(fld_index, value) 4534 return 4535 else: 4536 raise TypeError('Unsupported type of list in SetField2(). Type of element is %s' % str(type(value[0]))) 4537 4538 try: 4539 self.SetField(fld_index, value) 4540 except: 4541 self.SetField(fld_index, str(value)) 4542 return
4543
4544 - def keys(self):
4545 names = [] 4546 for i in range(self.GetFieldCount()): 4547 fieldname = self.GetFieldDefnRef(i).GetName() 4548 names.append(fieldname) 4549 return names
4550
4551 - def items(self):
4552 keys = self.keys() 4553 output = {} 4554 for key in keys: 4555 output[key] = self.GetField(key) 4556 return output
4557 - def geometry(self):
4558 return self.GetGeometryRef()
4559
4560 - def ExportToJson(self, as_object=False, options=None):
4561 """Exports a GeoJSON object which represents the Feature. The 4562 as_object parameter determines whether the returned value 4563 should be a Python object instead of a string. Defaults to False. 4564 The options parameter is passed to Geometry.ExportToJson()""" 4565 4566 try: 4567 import simplejson 4568 except ImportError: 4569 try: 4570 import json as simplejson 4571 except ImportError: 4572 raise ImportError("Unable to import simplejson or json, needed for ExportToJson.") 4573 4574 geom = self.GetGeometryRef() 4575 if geom is not None: 4576 if options is None: 4577 options = [] 4578 geom_json_string = geom.ExportToJson(options=options) 4579 geom_json_object = simplejson.loads(geom_json_string) 4580 else: 4581 geom_json_object = None 4582 4583 output = {'type':'Feature', 4584 'geometry': geom_json_object, 4585 'properties': {} 4586 } 4587 4588 fid = self.GetFID() 4589 if fid != NullFID: 4590 output['id'] = fid 4591 4592 for key in self.keys(): 4593 fld_defn = self.GetFieldDefnRef(self.GetFieldIndex(key)) 4594 if fld_defn.GetType() == _ogr.OFTInteger and fld_defn.GetSubType() == _ogr.OFSTBoolean: 4595 output['properties'][key] = bool(self.GetField(key)) 4596 else: 4597 output['properties'][key] = self.GetField(key) 4598 4599 if not as_object: 4600 output = simplejson.dumps(output) 4601 4602 return output
4603 4604 4605 4606 Feature_swigregister = _ogr.Feature_swigregister 4607 Feature_swigregister(Feature) 4608
4609 -class FeatureDefn(_object):
4610 """Proxy of C++ OGRFeatureDefnShadow class.""" 4611 4612 __swig_setmethods__ = {} 4613 __setattr__ = lambda self, name, value: _swig_setattr(self, FeatureDefn, name, value) 4614 __swig_getmethods__ = {} 4615 __getattr__ = lambda self, name: _swig_getattr(self, FeatureDefn, name) 4616 __repr__ = _swig_repr 4617 __swig_destroy__ = _ogr.delete_FeatureDefn 4618 __del__ = lambda self: None 4619
4620 - def __init__(self, *args, **kwargs):
4621 """__init__(OGRFeatureDefnShadow self, char const * name_null_ok=None) -> FeatureDefn""" 4622 this = _ogr.new_FeatureDefn(*args, **kwargs) 4623 try: 4624 self.this.append(this) 4625 except __builtin__.Exception: 4626 self.this = this
4627
4628 - def GetName(self, *args):
4629 """ 4630 GetName(FeatureDefn self) -> char const * 4631 4632 const char* 4633 OGR_FD_GetName(OGRFeatureDefnH hDefn) 4634 4635 Get name of the OGRFeatureDefn passed as an argument. 4636 4637 This function is the same as the C++ method OGRFeatureDefn::GetName(). 4638 4639 Parameters: 4640 ----------- 4641 4642 hDefn: handle to the feature definition to get the name from. 4643 4644 the name. This name is internal and should not be modified, or freed. 4645 4646 """ 4647 return _ogr.FeatureDefn_GetName(self, *args)
4648 4649
4650 - def GetFieldCount(self, *args):
4651 """ 4652 GetFieldCount(FeatureDefn self) -> int 4653 4654 int 4655 OGR_FD_GetFieldCount(OGRFeatureDefnH hDefn) 4656 4657 Fetch number of fields on the passed feature definition. 4658 4659 This function is the same as the C++ OGRFeatureDefn::GetFieldCount(). 4660 4661 Parameters: 4662 ----------- 4663 4664 hDefn: handle to the feature definition to get the fields count from. 4665 4666 count of fields. 4667 """ 4668 return _ogr.FeatureDefn_GetFieldCount(self, *args)
4669 4670
4671 - def GetFieldDefn(self, *args):
4672 """ 4673 GetFieldDefn(FeatureDefn self, int i) -> FieldDefn 4674 4675 OGRFieldDefnH 4676 OGR_FD_GetFieldDefn(OGRFeatureDefnH hDefn, int iField) 4677 4678 Fetch field definition of the passed feature definition. 4679 4680 This function is the same as the C++ method 4681 OGRFeatureDefn::GetFieldDefn(). 4682 4683 Parameters: 4684 ----------- 4685 4686 hDefn: handle to the feature definition to get the field definition 4687 from. 4688 4689 iField: the field to fetch, between 0 and GetFieldCount()-1. 4690 4691 a handle to an internal field definition object or NULL if invalid 4692 index. This object should not be modified or freed by the application. 4693 4694 """ 4695 return _ogr.FeatureDefn_GetFieldDefn(self, *args)
4696 4697
4698 - def GetFieldIndex(self, *args):
4699 """ 4700 GetFieldIndex(FeatureDefn self, char const * field_name) -> int 4701 4702 int 4703 OGR_FD_GetFieldIndex(OGRFeatureDefnH hDefn, const char *pszFieldName) 4704 4705 Find field by name. 4706 4707 The field index of the first field matching the passed field name 4708 (case insensitively) is returned. 4709 4710 This function is the same as the C++ method 4711 OGRFeatureDefn::GetFieldIndex. 4712 4713 Parameters: 4714 ----------- 4715 4716 hDefn: handle to the feature definition to get field index from. 4717 4718 pszFieldName: the field name to search for. 4719 4720 the field index, or -1 if no match found. 4721 """ 4722 return _ogr.FeatureDefn_GetFieldIndex(self, *args)
4723 4724
4725 - def AddFieldDefn(self, *args):
4726 """ 4727 AddFieldDefn(FeatureDefn self, FieldDefn defn) 4728 4729 void 4730 OGR_FD_AddFieldDefn(OGRFeatureDefnH hDefn, OGRFieldDefnH hNewField) 4731 4732 Add a new field definition to the passed feature definition. 4733 4734 To add a new field definition to a layer definition, do not use this 4735 function directly, but use OGR_L_CreateField() instead. 4736 4737 This function should only be called while there are no OGRFeature 4738 objects in existence based on this OGRFeatureDefn. The OGRFieldDefn 4739 passed in is copied, and remains the responsibility of the caller. 4740 4741 This function is the same as the C++ method 4742 OGRFeatureDefn::AddFieldDefn(). 4743 4744 Parameters: 4745 ----------- 4746 4747 hDefn: handle to the feature definition to add the field definition 4748 to. 4749 4750 hNewField: handle to the new field definition. 4751 """ 4752 return _ogr.FeatureDefn_AddFieldDefn(self, *args)
4753 4754
4755 - def GetGeomFieldCount(self, *args):
4756 """ 4757 GetGeomFieldCount(FeatureDefn self) -> int 4758 4759 int 4760 OGR_FD_GetGeomFieldCount(OGRFeatureDefnH hDefn) 4761 4762 Fetch number of geometry fields on the passed feature definition. 4763 4764 This function is the same as the C++ 4765 OGRFeatureDefn::GetGeomFieldCount(). 4766 4767 Parameters: 4768 ----------- 4769 4770 hDefn: handle to the feature definition to get the fields count from. 4771 4772 count of geometry fields. 4773 4774 GDAL 1.11 4775 """ 4776 return _ogr.FeatureDefn_GetGeomFieldCount(self, *args)
4777 4778
4779 - def GetGeomFieldDefn(self, *args):
4780 """ 4781 GetGeomFieldDefn(FeatureDefn self, int i) -> GeomFieldDefn 4782 4783 OGRGeomFieldDefnH 4784 OGR_FD_GetGeomFieldDefn(OGRFeatureDefnH hDefn, int iGeomField) 4785 4786 Fetch geometry field definition of the passed feature definition. 4787 4788 This function is the same as the C++ method 4789 OGRFeatureDefn::GetGeomFieldDefn(). 4790 4791 Parameters: 4792 ----------- 4793 4794 hDefn: handle to the feature definition to get the field definition 4795 from. 4796 4797 iGeomField: the geometry field to fetch, between 0 and 4798 GetGeomFieldCount() - 1. 4799 4800 a handle to an internal field definition object or NULL if invalid 4801 index. This object should not be modified or freed by the application. 4802 4803 GDAL 1.11 4804 """ 4805 return _ogr.FeatureDefn_GetGeomFieldDefn(self, *args)
4806 4807
4808 - def GetGeomFieldIndex(self, *args):
4809 """ 4810 GetGeomFieldIndex(FeatureDefn self, char const * field_name) -> int 4811 4812 int 4813 OGR_FD_GetGeomFieldIndex(OGRFeatureDefnH hDefn, const char 4814 *pszGeomFieldName) 4815 4816 Find geometry field by name. 4817 4818 The geometry field index of the first geometry field matching the 4819 passed field name (case insensitively) is returned. 4820 4821 This function is the same as the C++ method 4822 OGRFeatureDefn::GetGeomFieldIndex. 4823 4824 Parameters: 4825 ----------- 4826 4827 hDefn: handle to the feature definition to get field index from. 4828 4829 pszGeomFieldName: the geometry field name to search for. 4830 4831 the geometry field index, or -1 if no match found. 4832 """ 4833 return _ogr.FeatureDefn_GetGeomFieldIndex(self, *args)
4834 4835
4836 - def AddGeomFieldDefn(self, *args):
4837 """ 4838 AddGeomFieldDefn(FeatureDefn self, GeomFieldDefn defn) 4839 4840 void 4841 OGR_FD_AddGeomFieldDefn(OGRFeatureDefnH hDefn, OGRGeomFieldDefnH 4842 hNewGeomField) 4843 4844 Add a new field definition to the passed feature definition. 4845 4846 To add a new field definition to a layer definition, do not use this 4847 function directly, but use OGR_L_CreateGeomField() instead. 4848 4849 This function should only be called while there are no OGRFeature 4850 objects in existence based on this OGRFeatureDefn. The 4851 OGRGeomFieldDefn passed in is copied, and remains the responsibility 4852 of the caller. 4853 4854 This function is the same as the C++ method 4855 OGRFeatureDefn::AddGeomFieldDefn(). 4856 4857 Parameters: 4858 ----------- 4859 4860 hDefn: handle to the feature definition to add the geometry field 4861 definition to. 4862 4863 hNewGeomField: handle to the new field definition. 4864 4865 GDAL 1.11 4866 """ 4867 return _ogr.FeatureDefn_AddGeomFieldDefn(self, *args)
4868 4869
4870 - def DeleteGeomFieldDefn(self, *args):
4871 """ 4872 DeleteGeomFieldDefn(FeatureDefn self, int idx) -> OGRErr 4873 4874 OGRErr 4875 OGR_FD_DeleteGeomFieldDefn(OGRFeatureDefnH hDefn, int iGeomField) 4876 4877 Delete an existing geometry field definition. 4878 4879 To delete an existing geometry field definition from a layer 4880 definition, do not use this function directly, but use 4881 OGR_L_DeleteGeomField() instead ( not implemented yet). 4882 4883 This method should only be called while there are no OGRFeature 4884 objects in existence based on this OGRFeatureDefn. 4885 4886 This method is the same as the C++ method 4887 OGRFeatureDefn::DeleteGeomFieldDefn(). 4888 4889 Parameters: 4890 ----------- 4891 4892 hDefn: handle to the feature definition. 4893 4894 iGeomField: the index of the geometry field definition. 4895 4896 OGRERR_NONE in case of success. 4897 4898 GDAL 1.11 4899 """ 4900 return _ogr.FeatureDefn_DeleteGeomFieldDefn(self, *args)
4901 4902
4903 - def GetGeomType(self, *args):
4904 """ 4905 GetGeomType(FeatureDefn self) -> OGRwkbGeometryType 4906 4907 OGRwkbGeometryType 4908 OGR_FD_GetGeomType(OGRFeatureDefnH hDefn) 4909 4910 Fetch the geometry base type of the passed feature definition. 4911 4912 This function is the same as the C++ method 4913 OGRFeatureDefn::GetGeomType(). 4914 4915 Starting with GDAL 1.11, this method returns 4916 GetGeomFieldDefn(0)->GetType(). 4917 4918 Parameters: 4919 ----------- 4920 4921 hDefn: handle to the feature definition to get the geometry type 4922 from. 4923 4924 the base type for all geometry related to this definition. 4925 """ 4926 return _ogr.FeatureDefn_GetGeomType(self, *args)
4927 4928
4929 - def SetGeomType(self, *args):
4930 """ 4931 SetGeomType(FeatureDefn self, OGRwkbGeometryType geom_type) 4932 4933 void 4934 OGR_FD_SetGeomType(OGRFeatureDefnH hDefn, OGRwkbGeometryType eType) 4935 4936 Assign the base geometry type for the passed layer (the same as the 4937 feature definition). 4938 4939 All geometry objects using this type must be of the defined type or a 4940 derived type. The default upon creation is wkbUnknown which allows for 4941 any geometry type. The geometry type should generally not be changed 4942 after any OGRFeatures have been created against this definition. 4943 4944 This function is the same as the C++ method 4945 OGRFeatureDefn::SetGeomType(). 4946 4947 Starting with GDAL 1.11, this method calls 4948 GetGeomFieldDefn(0)->SetType(). 4949 4950 Parameters: 4951 ----------- 4952 4953 hDefn: handle to the layer or feature definition to set the geometry 4954 type to. 4955 4956 eType: the new type to assign. 4957 """ 4958 return _ogr.FeatureDefn_SetGeomType(self, *args)
4959 4960
4961 - def GetReferenceCount(self, *args):
4962 """ 4963 GetReferenceCount(FeatureDefn self) -> int 4964 4965 int 4966 OGR_FD_GetReferenceCount(OGRFeatureDefnH hDefn) 4967 4968 Fetch current reference count. 4969 4970 This function is the same as the C++ method 4971 OGRFeatureDefn::GetReferenceCount(). 4972 4973 Parameters: 4974 ----------- 4975 4976 hDefn: handle to the feature definition on witch OGRFeature are based 4977 on. 4978 4979 the current reference count. 4980 """ 4981 return _ogr.FeatureDefn_GetReferenceCount(self, *args)
4982 4983
4984 - def IsGeometryIgnored(self, *args):
4985 """ 4986 IsGeometryIgnored(FeatureDefn self) -> int 4987 4988 int 4989 OGR_FD_IsGeometryIgnored(OGRFeatureDefnH hDefn) 4990 4991 Determine whether the geometry can be omitted when fetching features. 4992 4993 This function is the same as the C++ method 4994 OGRFeatureDefn::IsGeometryIgnored(). 4995 4996 Starting with GDAL 1.11, this method returns 4997 GetGeomFieldDefn(0)->IsIgnored(). 4998 4999 Parameters: 5000 ----------- 5001 5002 hDefn: handle to the feature definition on witch OGRFeature are based 5003 on. 5004 5005 ignore state 5006 """ 5007 return _ogr.FeatureDefn_IsGeometryIgnored(self, *args)
5008 5009
5010 - def SetGeometryIgnored(self, *args):
5011 """ 5012 SetGeometryIgnored(FeatureDefn self, int bIgnored) 5013 5014 void 5015 OGR_FD_SetGeometryIgnored(OGRFeatureDefnH hDefn, int bIgnore) 5016 5017 Set whether the geometry can be omitted when fetching features. 5018 5019 This function is the same as the C++ method 5020 OGRFeatureDefn::SetGeometryIgnored(). 5021 5022 Starting with GDAL 1.11, this method calls 5023 GetGeomFieldDefn(0)->SetIgnored(). 5024 5025 Parameters: 5026 ----------- 5027 5028 hDefn: handle to the feature definition on witch OGRFeature are based 5029 on. 5030 5031 bIgnore: ignore state 5032 """ 5033 return _ogr.FeatureDefn_SetGeometryIgnored(self, *args)
5034 5035
5036 - def IsStyleIgnored(self, *args):
5037 """ 5038 IsStyleIgnored(FeatureDefn self) -> int 5039 5040 int 5041 OGR_FD_IsStyleIgnored(OGRFeatureDefnH hDefn) 5042 5043 Determine whether the style can be omitted when fetching features. 5044 5045 This function is the same as the C++ method 5046 OGRFeatureDefn::IsStyleIgnored(). 5047 5048 Parameters: 5049 ----------- 5050 5051 hDefn: handle to the feature definition on which OGRFeature are based 5052 on. 5053 5054 ignore state 5055 """ 5056 return _ogr.FeatureDefn_IsStyleIgnored(self, *args)
5057 5058
5059 - def SetStyleIgnored(self, *args):
5060 """ 5061 SetStyleIgnored(FeatureDefn self, int bIgnored) 5062 5063 void 5064 OGR_FD_SetStyleIgnored(OGRFeatureDefnH hDefn, int bIgnore) 5065 5066 Set whether the style can be omitted when fetching features. 5067 5068 This function is the same as the C++ method 5069 OGRFeatureDefn::SetStyleIgnored(). 5070 5071 Parameters: 5072 ----------- 5073 5074 hDefn: handle to the feature definition on witch OGRFeature are based 5075 on. 5076 5077 bIgnore: ignore state 5078 """ 5079 return _ogr.FeatureDefn_SetStyleIgnored(self, *args)
5080 5081
5082 - def IsSame(self, *args):
5083 """ 5084 IsSame(FeatureDefn self, FeatureDefn other_defn) -> int 5085 5086 int OGR_FD_IsSame(OGRFeatureDefnH 5087 hFDefn, OGRFeatureDefnH hOtherFDefn) 5088 5089 Test if the feature definition is identical to the other one. 5090 5091 Parameters: 5092 ----------- 5093 5094 hFDefn: handle to the feature definition on witch OGRFeature are 5095 based on. 5096 5097 hOtherFDefn: handle to the other feature definition to compare to. 5098 5099 TRUE if the feature definition is identical to the other one. 5100 5101 OGR 1.11 5102 """ 5103 return _ogr.FeatureDefn_IsSame(self, *args)
5104 5105
5106 - def Destroy(self):
5107 "Once called, self has effectively been destroyed. Do not access. For backwards compatibility only" 5108 _ogr.delete_FeatureDefn(self) 5109 self.thisown = 0
5110 5111 5112 FeatureDefn_swigregister = _ogr.FeatureDefn_swigregister 5113 FeatureDefn_swigregister(FeatureDefn) 5114
5115 -class FieldDefn(_object):
5116 """Proxy of C++ OGRFieldDefnShadow class.""" 5117 5118 __swig_setmethods__ = {} 5119 __setattr__ = lambda self, name, value: _swig_setattr(self, FieldDefn, name, value) 5120 __swig_getmethods__ = {} 5121 __getattr__ = lambda self, name: _swig_getattr(self, FieldDefn, name) 5122 __repr__ = _swig_repr 5123 __swig_destroy__ = _ogr.delete_FieldDefn 5124 __del__ = lambda self: None 5125
5126 - def __init__(self, *args, **kwargs):
5127 """__init__(OGRFieldDefnShadow self, char const * name_null_ok, OGRFieldType field_type) -> FieldDefn""" 5128 this = _ogr.new_FieldDefn(*args, **kwargs) 5129 try: 5130 self.this.append(this) 5131 except __builtin__.Exception: 5132 self.this = this
5133
5134 - def GetName(self, *args):
5135 """GetName(FieldDefn self) -> char const *""" 5136 return _ogr.FieldDefn_GetName(self, *args)
5137 5138
5139 - def GetNameRef(self, *args):
5140 """ 5141 GetNameRef(FieldDefn self) -> char const * 5142 5143 const char* 5144 OGR_Fld_GetNameRef(OGRFieldDefnH hDefn) 5145 5146 Fetch name of this field. 5147 5148 This function is the same as the CPP method 5149 OGRFieldDefn::GetNameRef(). 5150 5151 Parameters: 5152 ----------- 5153 5154 hDefn: handle to the field definition. 5155 5156 the name of the field definition. 5157 """ 5158 return _ogr.FieldDefn_GetNameRef(self, *args)
5159 5160
5161 - def SetName(self, *args):
5162 """ 5163 SetName(FieldDefn self, char const * name) 5164 5165 void OGR_Fld_SetName(OGRFieldDefnH 5166 hDefn, const char *pszName) 5167 5168 Reset the name of this field. 5169 5170 This function is the same as the CPP method OGRFieldDefn::SetName(). 5171 5172 Parameters: 5173 ----------- 5174 5175 hDefn: handle to the field definition to apply the new name to. 5176 5177 pszName: the new name to apply. 5178 """ 5179 return _ogr.FieldDefn_SetName(self, *args)
5180 5181
5182 - def GetAlternativeName(self, *args):
5183 """GetAlternativeName(FieldDefn self) -> char const *""" 5184 return _ogr.FieldDefn_GetAlternativeName(self, *args)
5185 5186
5187 - def GetAlternativeNameRef(self, *args):
5188 """ 5189 GetAlternativeNameRef(FieldDefn self) -> char const * 5190 5191 const char* 5192 OGR_Fld_GetAlternativeNameRef(OGRFieldDefnH hDefn) 5193 5194 Fetch the alternative name (or "alias") for this field. 5195 5196 The alternative name is an optional attribute for a field which can 5197 provide a more user-friendly, descriptive name of a field which is not 5198 subject to the usual naming constraints defined by the data provider. 5199 5200 This is a metadata style attribute only: the alternative name cannot 5201 be used in place of the actual field name during SQL queries or other 5202 field name dependent API calls. 5203 5204 This function is the same as the CPP method 5205 OGRFieldDefn::GetAlternativeNameRef(). 5206 5207 Parameters: 5208 ----------- 5209 5210 hDefn: handle to the field definition. 5211 5212 the alternative name of the field definition. 5213 5214 GDAL 3.2 5215 """ 5216 return _ogr.FieldDefn_GetAlternativeNameRef(self, *args)
5217 5218
5219 - def SetAlternativeName(self, *args):
5220 """ 5221 SetAlternativeName(FieldDefn self, char const * alternativeName) 5222 5223 void 5224 OGR_Fld_SetAlternativeName(OGRFieldDefnH hDefn, const char 5225 *pszAlternativeName) 5226 5227 Reset the alternative name (or "alias") for this field. 5228 5229 The alternative name is an optional attribute for a field which can 5230 provide a more user-friendly, descriptive name of a field which is not 5231 subject to the usual naming constraints defined by the data provider. 5232 5233 This is a metadata style attribute only: the alternative name cannot 5234 be used in place of the actual field name during SQL queries or other 5235 field name dependent API calls. 5236 5237 This function is the same as the CPP method 5238 OGRFieldDefn::SetAlternativeName(). 5239 5240 Parameters: 5241 ----------- 5242 5243 hDefn: handle to the field definition to apply the new alternative 5244 name to. 5245 5246 pszAlternativeName: the new alternative name to apply. 5247 5248 GDAL 3.2 5249 """ 5250 return _ogr.FieldDefn_SetAlternativeName(self, *args)
5251 5252
5253 - def GetType(self, *args):
5254 """ 5255 GetType(FieldDefn self) -> OGRFieldType 5256 5257 OGRFieldType 5258 OGR_Fld_GetType(OGRFieldDefnH hDefn) 5259 5260 Fetch type of this field. 5261 5262 This function is the same as the CPP method OGRFieldDefn::GetType(). 5263 5264 Parameters: 5265 ----------- 5266 5267 hDefn: handle to the field definition to get type from. 5268 5269 field type. 5270 """ 5271 return _ogr.FieldDefn_GetType(self, *args)
5272 5273
5274 - def SetType(self, *args):
5275 """ 5276 SetType(FieldDefn self, OGRFieldType type) 5277 5278 void OGR_Fld_SetType(OGRFieldDefnH 5279 hDefn, OGRFieldType eType) 5280 5281 Set the type of this field. 5282 5283 This should never be done to an OGRFieldDefn that is already part of 5284 an OGRFeatureDefn. 5285 5286 This function is the same as the CPP method OGRFieldDefn::SetType(). 5287 5288 Parameters: 5289 ----------- 5290 5291 hDefn: handle to the field definition to set type to. 5292 5293 eType: the new field type. 5294 """ 5295 return _ogr.FieldDefn_SetType(self, *args)
5296 5297
5298 - def GetSubType(self, *args):
5299 """ 5300 GetSubType(FieldDefn self) -> OGRFieldSubType 5301 5302 OGRFieldSubType 5303 OGR_Fld_GetSubType(OGRFieldDefnH hDefn) 5304 5305 Fetch subtype of this field. 5306 5307 This function is the same as the CPP method 5308 OGRFieldDefn::GetSubType(). 5309 5310 Parameters: 5311 ----------- 5312 5313 hDefn: handle to the field definition to get subtype from. 5314 5315 field subtype. 5316 5317 GDAL 2.0 5318 """ 5319 return _ogr.FieldDefn_GetSubType(self, *args)
5320 5321
5322 - def SetSubType(self, *args):
5323 """ 5324 SetSubType(FieldDefn self, OGRFieldSubType type) 5325 5326 void 5327 OGR_Fld_SetSubType(OGRFieldDefnH hDefn, OGRFieldSubType eSubType) 5328 5329 Set the subtype of this field. 5330 5331 This should never be done to an OGRFieldDefn that is already part of 5332 an OGRFeatureDefn. 5333 5334 This function is the same as the CPP method 5335 OGRFieldDefn::SetSubType(). 5336 5337 Parameters: 5338 ----------- 5339 5340 hDefn: handle to the field definition to set type to. 5341 5342 eSubType: the new field subtype. 5343 5344 GDAL 2.0 5345 """ 5346 return _ogr.FieldDefn_SetSubType(self, *args)
5347 5348
5349 - def GetJustify(self, *args):
5350 """ 5351 GetJustify(FieldDefn self) -> OGRJustification 5352 5353 OGRJustification 5354 OGR_Fld_GetJustify(OGRFieldDefnH hDefn) 5355 5356 Get the justification for this field. 5357 5358 This function is the same as the CPP method 5359 OGRFieldDefn::GetJustify(). 5360 5361 Note: no driver is know to use the concept of field justification. 5362 5363 Parameters: 5364 ----------- 5365 5366 hDefn: handle to the field definition to get justification from. 5367 5368 the justification. 5369 """ 5370 return _ogr.FieldDefn_GetJustify(self, *args)
5371 5372
5373 - def SetJustify(self, *args):
5374 """ 5375 SetJustify(FieldDefn self, OGRJustification justify) 5376 5377 void 5378 OGR_Fld_SetJustify(OGRFieldDefnH hDefn, OGRJustification eJustify) 5379 5380 Set the justification for this field. 5381 5382 Note: no driver is know to use the concept of field justification. 5383 5384 This function is the same as the CPP method 5385 OGRFieldDefn::SetJustify(). 5386 5387 Parameters: 5388 ----------- 5389 5390 hDefn: handle to the field definition to set justification to. 5391 5392 eJustify: the new justification. 5393 """ 5394 return _ogr.FieldDefn_SetJustify(self, *args)
5395 5396
5397 - def GetWidth(self, *args):
5398 """ 5399 GetWidth(FieldDefn self) -> int 5400 5401 int OGR_Fld_GetWidth(OGRFieldDefnH 5402 hDefn) 5403 5404 Get the formatting width for this field. 5405 5406 This function is the same as the CPP method OGRFieldDefn::GetWidth(). 5407 5408 Parameters: 5409 ----------- 5410 5411 hDefn: handle to the field definition to get width from. 5412 5413 the width, zero means no specified width. 5414 """ 5415 return _ogr.FieldDefn_GetWidth(self, *args)
5416 5417
5418 - def SetWidth(self, *args):
5419 """ 5420 SetWidth(FieldDefn self, int width) 5421 5422 void OGR_Fld_SetWidth(OGRFieldDefnH 5423 hDefn, int nNewWidth) 5424 5425 Set the formatting width for this field in characters. 5426 5427 This function is the same as the CPP method OGRFieldDefn::SetWidth(). 5428 5429 Parameters: 5430 ----------- 5431 5432 hDefn: handle to the field definition to set width to. 5433 5434 nNewWidth: the new width. 5435 """ 5436 return _ogr.FieldDefn_SetWidth(self, *args)
5437 5438
5439 - def GetPrecision(self, *args):
5440 """ 5441 GetPrecision(FieldDefn self) -> int 5442 5443 int 5444 OGR_Fld_GetPrecision(OGRFieldDefnH hDefn) 5445 5446 Get the formatting precision for this field. 5447 5448 This should normally be zero for fields of types other than OFTReal. 5449 5450 This function is the same as the CPP method 5451 OGRFieldDefn::GetPrecision(). 5452 5453 Parameters: 5454 ----------- 5455 5456 hDefn: handle to the field definition to get precision from. 5457 5458 the precision. 5459 """ 5460 return _ogr.FieldDefn_GetPrecision(self, *args)
5461 5462
5463 - def SetPrecision(self, *args):
5464 """ 5465 SetPrecision(FieldDefn self, int precision) 5466 5467 void 5468 OGR_Fld_SetPrecision(OGRFieldDefnH hDefn, int nPrecision) 5469 5470 Set the formatting precision for this field in characters. 5471 5472 This should normally be zero for fields of types other than OFTReal. 5473 5474 This function is the same as the CPP method 5475 OGRFieldDefn::SetPrecision(). 5476 5477 Parameters: 5478 ----------- 5479 5480 hDefn: handle to the field definition to set precision to. 5481 5482 nPrecision: the new precision. 5483 """ 5484 return _ogr.FieldDefn_SetPrecision(self, *args)
5485 5486
5487 - def GetTypeName(self, *args):
5488 """GetTypeName(FieldDefn self) -> char const *""" 5489 return _ogr.FieldDefn_GetTypeName(self, *args)
5490 5491
5492 - def GetFieldTypeName(self, *args):
5493 """GetFieldTypeName(FieldDefn self, OGRFieldType type) -> char const *""" 5494 return _ogr.FieldDefn_GetFieldTypeName(self, *args)
5495 5496
5497 - def IsIgnored(self, *args):
5498 """ 5499 IsIgnored(FieldDefn self) -> int 5500 5501 int OGR_Fld_IsIgnored(OGRFieldDefnH 5502 hDefn) 5503 5504 Return whether this field should be omitted when fetching features. 5505 5506 This method is the same as the C++ method OGRFieldDefn::IsIgnored(). 5507 5508 Parameters: 5509 ----------- 5510 5511 hDefn: handle to the field definition 5512 5513 ignore state 5514 """ 5515 return _ogr.FieldDefn_IsIgnored(self, *args)
5516 5517
5518 - def SetIgnored(self, *args):
5519 """ 5520 SetIgnored(FieldDefn self, int bIgnored) 5521 5522 void 5523 OGR_Fld_SetIgnored(OGRFieldDefnH hDefn, int ignore) 5524 5525 Set whether this field should be omitted when fetching features. 5526 5527 This method is the same as the C++ method OGRFieldDefn::SetIgnored(). 5528 5529 Parameters: 5530 ----------- 5531 5532 hDefn: handle to the field definition 5533 5534 ignore: ignore state 5535 """ 5536 return _ogr.FieldDefn_SetIgnored(self, *args)
5537 5538
5539 - def IsNullable(self, *args):
5540 """ 5541 IsNullable(FieldDefn self) -> int 5542 5543 int 5544 OGR_Fld_IsNullable(OGRFieldDefnH hDefn) 5545 5546 Return whether this field can receive null values. 5547 5548 By default, fields are nullable. 5549 5550 Even if this method returns FALSE (i.e not-nullable field), it doesn't 5551 mean that OGRFeature::IsFieldSet() will necessary return TRUE, as 5552 fields can be temporary unset and null /not-null validation is usually 5553 done when OGRLayer::CreateFeature()/SetFeature() is called. 5554 5555 This method is the same as the C++ method OGRFieldDefn::IsNullable(). 5556 5557 Parameters: 5558 ----------- 5559 5560 hDefn: handle to the field definition 5561 5562 TRUE if the field is authorized to be null. 5563 5564 GDAL 2.0 5565 """ 5566 return _ogr.FieldDefn_IsNullable(self, *args)
5567 5568
5569 - def SetNullable(self, *args):
5570 """ 5571 SetNullable(FieldDefn self, int bNullable) 5572 5573 void 5574 OGR_Fld_SetNullable(OGRFieldDefnH hDefn, int bNullableIn) 5575 5576 Set whether this field can receive null values. 5577 5578 By default, fields are nullable, so this method is generally called 5579 with FALSE to set a not-null constraint. 5580 5581 Drivers that support writing not-null constraint will advertise the 5582 GDAL_DCAP_NOTNULL_FIELDS driver metadata item. 5583 5584 This method is the same as the C++ method OGRFieldDefn::SetNullable(). 5585 5586 Parameters: 5587 ----------- 5588 5589 hDefn: handle to the field definition 5590 5591 bNullableIn: FALSE if the field must have a not-null constraint. 5592 5593 GDAL 2.0 5594 """ 5595 return _ogr.FieldDefn_SetNullable(self, *args)
5596 5597
5598 - def IsUnique(self, *args):
5599 """ 5600 IsUnique(FieldDefn self) -> int 5601 5602 int OGR_Fld_IsUnique(OGRFieldDefnH 5603 hDefn) 5604 5605 Return whether this field has a unique constraint. 5606 5607 By default, fields have no unique constraint. 5608 5609 This method is the same as the C++ method OGRFieldDefn::IsUnique(). 5610 5611 Parameters: 5612 ----------- 5613 5614 hDefn: handle to the field definition 5615 5616 TRUE if the field has a unique constraint. 5617 5618 GDAL 3.2 5619 """ 5620 return _ogr.FieldDefn_IsUnique(self, *args)
5621 5622
5623 - def SetUnique(self, *args):
5624 """ 5625 SetUnique(FieldDefn self, int bUnique) 5626 5627 void 5628 OGR_Fld_SetUnique(OGRFieldDefnH hDefn, int bUniqueIn) 5629 5630 Set whether this field has a unique constraint. 5631 5632 By default, fields have no unique constraint, so this method is 5633 generally called with TRUE to set a unique constraint. 5634 5635 Drivers that support writing unique constraint will advertise the 5636 GDAL_DCAP_UNIQUE_FIELDS driver metadata item. field can receive null 5637 values. 5638 5639 This method is the same as the C++ method OGRFieldDefn::SetUnique(). 5640 5641 Parameters: 5642 ----------- 5643 5644 hDefn: handle to the field definition 5645 5646 bUniqueIn: TRUE if the field must have a unique constraint. 5647 5648 GDAL 3.2 5649 """ 5650 return _ogr.FieldDefn_SetUnique(self, *args)
5651 5652
5653 - def GetDefault(self, *args):
5654 """ 5655 GetDefault(FieldDefn self) -> char const * 5656 5657 const char* 5658 OGR_Fld_GetDefault(OGRFieldDefnH hDefn) 5659 5660 Get default field value. 5661 5662 This function is the same as the C++ method 5663 OGRFieldDefn::GetDefault(). 5664 5665 Parameters: 5666 ----------- 5667 5668 hDefn: handle to the field definition. 5669 5670 default field value or NULL. 5671 5672 GDAL 2.0 5673 """ 5674 return _ogr.FieldDefn_GetDefault(self, *args)
5675 5676
5677 - def SetDefault(self, *args):
5678 """ 5679 SetDefault(FieldDefn self, char const * pszValue) 5680 5681 void 5682 OGR_Fld_SetDefault(OGRFieldDefnH hDefn, const char *pszDefault) 5683 5684 Set default field value. 5685 5686 The default field value is taken into account by drivers (generally 5687 those with a SQL interface) that support it at field creation time. 5688 OGR will generally not automatically set the default field value to 5689 null fields by itself when calling OGRFeature::CreateFeature() / 5690 OGRFeature::SetFeature(), but will let the low-level layers to do the 5691 job. So retrieving the feature from the layer is recommended. 5692 5693 The accepted values are NULL, a numeric value, a literal value 5694 enclosed between single quote characters (and inner single quote 5695 characters escaped by repetition of the single quote character), 5696 CURRENT_TIMESTAMP, CURRENT_TIME, CURRENT_DATE or a driver specific 5697 expression (that might be ignored by other drivers). For a datetime 5698 literal value, format should be 'YYYY/MM/DD HH:MM:SS[.sss]' 5699 (considered as UTC time). 5700 5701 Drivers that support writing DEFAULT clauses will advertise the 5702 GDAL_DCAP_DEFAULT_FIELDS driver metadata item. 5703 5704 This function is the same as the C++ method 5705 OGRFieldDefn::SetDefault(). 5706 5707 Parameters: 5708 ----------- 5709 5710 hDefn: handle to the field definition. 5711 5712 pszDefault: new default field value or NULL pointer. 5713 5714 GDAL 2.0 5715 """ 5716 return _ogr.FieldDefn_SetDefault(self, *args)
5717 5718
5719 - def IsDefaultDriverSpecific(self, *args):
5720 """ 5721 IsDefaultDriverSpecific(FieldDefn self) -> int 5722 5723 int 5724 OGR_Fld_IsDefaultDriverSpecific(OGRFieldDefnH hDefn) 5725 5726 Returns whether the default value is driver specific. 5727 5728 Driver specific default values are those that are not NULL, a numeric 5729 value, a literal value enclosed between single quote characters, 5730 CURRENT_TIMESTAMP, CURRENT_TIME, CURRENT_DATE or datetime literal 5731 value. 5732 5733 This function is the same as the C++ method 5734 OGRFieldDefn::IsDefaultDriverSpecific(). 5735 5736 Parameters: 5737 ----------- 5738 5739 hDefn: handle to the field definition 5740 5741 TRUE if the default value is driver specific. 5742 5743 GDAL 2.0 5744 """ 5745 return _ogr.FieldDefn_IsDefaultDriverSpecific(self, *args)
5746 5747 5748 width = property(GetWidth, SetWidth) 5749 type = property(GetType, SetType) 5750 precision = property(GetPrecision, SetPrecision) 5751 name = property(GetName, SetName) 5752 justify = property(GetJustify, SetJustify) 5753 5754
5755 - def Destroy(self):
5756 "Once called, self has effectively been destroyed. Do not access. For backwards compatibility only" 5757 _ogr.delete_FieldDefn(self) 5758 self.thisown = 0
5759 5760 FieldDefn_swigregister = _ogr.FieldDefn_swigregister 5761 FieldDefn_swigregister(FieldDefn) 5762
5763 -class GeomFieldDefn(_object):
5764 """Proxy of C++ OGRGeomFieldDefnShadow class.""" 5765 5766 __swig_setmethods__ = {} 5767 __setattr__ = lambda self, name, value: _swig_setattr(self, GeomFieldDefn, name, value) 5768 __swig_getmethods__ = {} 5769 __getattr__ = lambda self, name: _swig_getattr(self, GeomFieldDefn, name) 5770 __repr__ = _swig_repr 5771 __swig_destroy__ = _ogr.delete_GeomFieldDefn 5772 __del__ = lambda self: None 5773
5774 - def __init__(self, *args, **kwargs):
5775 """__init__(OGRGeomFieldDefnShadow self, char const * name_null_ok, OGRwkbGeometryType field_type) -> GeomFieldDefn""" 5776 this = _ogr.new_GeomFieldDefn(*args, **kwargs) 5777 try: 5778 self.this.append(this) 5779 except __builtin__.Exception: 5780 self.this = this
5781
5782 - def GetName(self, *args):
5783 """GetName(GeomFieldDefn self) -> char const *""" 5784 return _ogr.GeomFieldDefn_GetName(self, *args)
5785 5786
5787 - def GetNameRef(self, *args):
5788 """GetNameRef(GeomFieldDefn self) -> char const *""" 5789 return _ogr.GeomFieldDefn_GetNameRef(self, *args)
5790 5791
5792 - def SetName(self, *args):
5793 """SetName(GeomFieldDefn self, char const * name)""" 5794 return _ogr.GeomFieldDefn_SetName(self, *args)
5795 5796
5797 - def GetType(self, *args):
5798 """GetType(GeomFieldDefn self) -> OGRwkbGeometryType""" 5799 return _ogr.GeomFieldDefn_GetType(self, *args)
5800 5801
5802 - def SetType(self, *args):
5803 """SetType(GeomFieldDefn self, OGRwkbGeometryType type)""" 5804 return _ogr.GeomFieldDefn_SetType(self, *args)
5805 5806
5807 - def GetSpatialRef(self, *args):
5808 """GetSpatialRef(GeomFieldDefn self) -> SpatialReference""" 5809 return _ogr.GeomFieldDefn_GetSpatialRef(self, *args)
5810 5811
5812 - def SetSpatialRef(self, *args):
5813 """SetSpatialRef(GeomFieldDefn self, SpatialReference srs)""" 5814 return _ogr.GeomFieldDefn_SetSpatialRef(self, *args)
5815 5816
5817 - def IsIgnored(self, *args):
5818 """IsIgnored(GeomFieldDefn self) -> int""" 5819 return _ogr.GeomFieldDefn_IsIgnored(self, *args)
5820 5821
5822 - def SetIgnored(self, *args):
5823 """SetIgnored(GeomFieldDefn self, int bIgnored)""" 5824 return _ogr.GeomFieldDefn_SetIgnored(self, *args)
5825 5826
5827 - def IsNullable(self, *args):
5828 """IsNullable(GeomFieldDefn self) -> int""" 5829 return _ogr.GeomFieldDefn_IsNullable(self, *args)
5830 5831
5832 - def SetNullable(self, *args):
5833 """SetNullable(GeomFieldDefn self, int bNullable)""" 5834 return _ogr.GeomFieldDefn_SetNullable(self, *args)
5835 5836 5837 type = property(GetType, SetType) 5838 name = property(GetName, SetName) 5839 srs = property(GetSpatialRef, SetSpatialRef)
5840 5841 GeomFieldDefn_swigregister = _ogr.GeomFieldDefn_swigregister 5842 GeomFieldDefn_swigregister(GeomFieldDefn) 5843 5844
5845 -def CreateGeometryFromWkb(*args, **kwargs):
5846 """CreateGeometryFromWkb(int len, SpatialReference reference=None) -> Geometry""" 5847 return _ogr.CreateGeometryFromWkb(*args, **kwargs)
5848
5849 -def CreateGeometryFromWkt(*args, **kwargs):
5850 """CreateGeometryFromWkt(char ** val, SpatialReference reference=None) -> Geometry""" 5851 return _ogr.CreateGeometryFromWkt(*args, **kwargs)
5852
5853 -def CreateGeometryFromGML(*args):
5854 """CreateGeometryFromGML(char const * input_string) -> Geometry""" 5855 return _ogr.CreateGeometryFromGML(*args)
5856
5857 -def CreateGeometryFromJson(*args):
5858 """CreateGeometryFromJson(char const * input_string) -> Geometry""" 5859 return _ogr.CreateGeometryFromJson(*args)
5860
5861 -def CreateGeometryFromEsriJson(*args):
5862 """CreateGeometryFromEsriJson(char const * input_string) -> Geometry""" 5863 return _ogr.CreateGeometryFromEsriJson(*args)
5864
5865 -def BuildPolygonFromEdges(*args, **kwargs):
5866 """BuildPolygonFromEdges(Geometry hLineCollection, int bBestEffort=0, int bAutoClose=0, double dfTolerance=0) -> Geometry""" 5867 return _ogr.BuildPolygonFromEdges(*args, **kwargs)
5868
5869 -def ApproximateArcAngles(*args, **kwargs):
5870 """ApproximateArcAngles(double dfCenterX, double dfCenterY, double dfZ, double dfPrimaryRadius, double dfSecondaryAxis, double dfRotation, double dfStartAngle, double dfEndAngle, double dfMaxAngleStepSizeDegrees) -> Geometry""" 5871 return _ogr.ApproximateArcAngles(*args, **kwargs)
5872
5873 -def ForceToPolygon(*args):
5874 """ForceToPolygon(Geometry geom_in) -> Geometry""" 5875 return _ogr.ForceToPolygon(*args)
5876
5877 -def ForceToLineString(*args):
5878 """ForceToLineString(Geometry geom_in) -> Geometry""" 5879 return _ogr.ForceToLineString(*args)
5880
5881 -def ForceToMultiPolygon(*args):
5882 """ForceToMultiPolygon(Geometry geom_in) -> Geometry""" 5883 return _ogr.ForceToMultiPolygon(*args)
5884
5885 -def ForceToMultiPoint(*args):
5886 """ForceToMultiPoint(Geometry geom_in) -> Geometry""" 5887 return _ogr.ForceToMultiPoint(*args)
5888
5889 -def ForceToMultiLineString(*args):
5890 """ForceToMultiLineString(Geometry geom_in) -> Geometry""" 5891 return _ogr.ForceToMultiLineString(*args)
5892
5893 -def ForceTo(*args):
5894 """ForceTo(Geometry geom_in, OGRwkbGeometryType eTargetType, char ** options=None) -> Geometry""" 5895 return _ogr.ForceTo(*args)
5896 -class Geometry(_object):
5897 """Proxy of C++ OGRGeometryShadow class.""" 5898 5899 __swig_setmethods__ = {} 5900 __setattr__ = lambda self, name, value: _swig_setattr(self, Geometry, name, value) 5901 __swig_getmethods__ = {} 5902 __getattr__ = lambda self, name: _swig_getattr(self, Geometry, name) 5903 __repr__ = _swig_repr 5904 __swig_destroy__ = _ogr.delete_Geometry 5905 __del__ = lambda self: None 5906
5907 - def __init__(self, *args, **kwargs):
5908 """__init__(OGRGeometryShadow self, OGRwkbGeometryType type, char * wkt=None, int wkb=0, char * gml=None) -> Geometry""" 5909 this = _ogr.new_Geometry(*args, **kwargs) 5910 try: 5911 self.this.append(this) 5912 except __builtin__.Exception: 5913 self.this = this
5914
5915 - def ExportToWkt(self, *args):
5916 """ 5917 ExportToWkt(Geometry self) -> OGRErr 5918 5919 OGRErr 5920 OGR_G_ExportToWkt(OGRGeometryH hGeom, char **ppszSrcText) 5921 5922 Convert a geometry into well known text format. 5923 5924 This function relates to the SFCOM IWks::ExportToWKT() method. 5925 5926 For backward compatibility purposes, it exports the Old-style 99-402 5927 extended dimension (Z) WKB types for types Point, LineString, Polygon, 5928 MultiPoint, MultiLineString, MultiPolygon and GeometryCollection. For 5929 other geometry types, it is equivalent to OGR_G_ExportToIsoWkt(). 5930 5931 This function is the same as the CPP method 5932 OGRGeometry::exportToWkt(). 5933 5934 Parameters: 5935 ----------- 5936 5937 hGeom: handle on the geometry to convert to a text format from. 5938 5939 ppszSrcText: a text buffer is allocated by the program, and assigned 5940 to the passed pointer. After use, *ppszDstText should be freed with 5941 CPLFree(). 5942 5943 Currently OGRERR_NONE is always returned. 5944 """ 5945 return _ogr.Geometry_ExportToWkt(self, *args)
5946 5947
5948 - def ExportToIsoWkt(self, *args):
5949 """ 5950 ExportToIsoWkt(Geometry self) -> OGRErr 5951 5952 OGRErr 5953 OGR_G_ExportToIsoWkt(OGRGeometryH hGeom, char **ppszSrcText) 5954 5955 Convert a geometry into SFSQL 1.2 / ISO SQL/MM Part 3 well known text 5956 format. 5957 5958 This function relates to the SFCOM IWks::ExportToWKT() method. It 5959 exports the SFSQL 1.2 and ISO SQL/MM Part 3 extended dimension (Z&M) 5960 WKB types. 5961 5962 This function is the same as the CPP method 5963 OGRGeometry::exportToWkt(wkbVariantIso). 5964 5965 Parameters: 5966 ----------- 5967 5968 hGeom: handle on the geometry to convert to a text format from. 5969 5970 ppszSrcText: a text buffer is allocated by the program, and assigned 5971 to the passed pointer. After use, *ppszDstText should be freed with 5972 CPLFree(). 5973 5974 Currently OGRERR_NONE is always returned. 5975 5976 GDAL 2.0 5977 """ 5978 return _ogr.Geometry_ExportToIsoWkt(self, *args)
5979 5980
5981 - def ExportToWkb(self, *args, **kwargs):
5982 """ 5983 ExportToWkb(Geometry self, OGRwkbByteOrder byte_order) -> OGRErr 5984 5985 OGRErr 5986 OGR_G_ExportToWkb(OGRGeometryH hGeom, OGRwkbByteOrder eOrder, unsigned 5987 char *pabyDstBuffer) 5988 5989 Convert a geometry well known binary format. 5990 5991 This function relates to the SFCOM IWks::ExportToWKB() method. 5992 5993 For backward compatibility purposes, it exports the Old-style 99-402 5994 extended dimension (Z) WKB types for types Point, LineString, Polygon, 5995 MultiPoint, MultiLineString, MultiPolygon and GeometryCollection. For 5996 other geometry types, it is equivalent to OGR_G_ExportToIsoWkb(). 5997 5998 This function is the same as the CPP method 5999 OGRGeometry::exportToWkb(OGRwkbByteOrder, unsigned char *, 6000 OGRwkbVariant) with eWkbVariant = wkbVariantOldOgc. 6001 6002 Parameters: 6003 ----------- 6004 6005 hGeom: handle on the geometry to convert to a well know binary data 6006 from. 6007 6008 eOrder: One of wkbXDR or wkbNDR indicating MSB or LSB byte order 6009 respectively. 6010 6011 pabyDstBuffer: a buffer into which the binary representation is 6012 written. This buffer must be at least OGR_G_WkbSize() byte in size. 6013 6014 Currently OGRERR_NONE is always returned. 6015 """ 6016 return _ogr.Geometry_ExportToWkb(self, *args, **kwargs)
6017 6018
6019 - def ExportToIsoWkb(self, *args, **kwargs):
6020 """ 6021 ExportToIsoWkb(Geometry self, OGRwkbByteOrder byte_order) -> OGRErr 6022 6023 OGRErr 6024 OGR_G_ExportToIsoWkb(OGRGeometryH hGeom, OGRwkbByteOrder eOrder, 6025 unsigned char *pabyDstBuffer) 6026 6027 Convert a geometry into SFSQL 1.2 / ISO SQL/MM Part 3 well known 6028 binary format. 6029 6030 This function relates to the SFCOM IWks::ExportToWKB() method. It 6031 exports the SFSQL 1.2 and ISO SQL/MM Part 3 extended dimension (Z&M) 6032 WKB types. 6033 6034 This function is the same as the CPP method 6035 OGRGeometry::exportToWkb(OGRwkbByteOrder, unsigned char *, 6036 OGRwkbVariant) with eWkbVariant = wkbVariantIso. 6037 6038 Parameters: 6039 ----------- 6040 6041 hGeom: handle on the geometry to convert to a well know binary data 6042 from. 6043 6044 eOrder: One of wkbXDR or wkbNDR indicating MSB or LSB byte order 6045 respectively. 6046 6047 pabyDstBuffer: a buffer into which the binary representation is 6048 written. This buffer must be at least OGR_G_WkbSize() byte in size. 6049 6050 Currently OGRERR_NONE is always returned. 6051 6052 GDAL 2.0 6053 """ 6054 return _ogr.Geometry_ExportToIsoWkb(self, *args, **kwargs)
6055 6056
6057 - def ExportToGML(self, *args, **kwargs):
6058 """ExportToGML(Geometry self, char ** options=None) -> retStringAndCPLFree *""" 6059 return _ogr.Geometry_ExportToGML(self, *args, **kwargs)
6060 6061
6062 - def ExportToKML(self, *args):
6063 """ExportToKML(Geometry self, char const * altitude_mode=None) -> retStringAndCPLFree *""" 6064 return _ogr.Geometry_ExportToKML(self, *args)
6065 6066
6067 - def ExportToJson(self, *args, **kwargs):
6068 """ExportToJson(Geometry self, char ** options=None) -> retStringAndCPLFree *""" 6069 return _ogr.Geometry_ExportToJson(self, *args, **kwargs)
6070 6071
6072 - def AddPoint(self, *args, **kwargs):
6073 """AddPoint(Geometry self, double x, double y, double z=0)""" 6074 return _ogr.Geometry_AddPoint(self, *args, **kwargs)
6075 6076
6077 - def AddPointM(self, *args, **kwargs):
6078 """AddPointM(Geometry self, double x, double y, double m)""" 6079 return _ogr.Geometry_AddPointM(self, *args, **kwargs)
6080 6081
6082 - def AddPointZM(self, *args, **kwargs):
6083 """AddPointZM(Geometry self, double x, double y, double z, double m)""" 6084 return _ogr.Geometry_AddPointZM(self, *args, **kwargs)
6085 6086
6087 - def AddPoint_2D(self, *args):
6088 """AddPoint_2D(Geometry self, double x, double y)""" 6089 return _ogr.Geometry_AddPoint_2D(self, *args)
6090 6091
6092 - def AddGeometryDirectly(self, *args):
6093 """AddGeometryDirectly(Geometry self, Geometry other_disown) -> OGRErr""" 6094 return _ogr.Geometry_AddGeometryDirectly(self, *args)
6095 6096
6097 - def AddGeometry(self, *args):
6098 """AddGeometry(Geometry self, Geometry other) -> OGRErr""" 6099 return _ogr.Geometry_AddGeometry(self, *args)
6100 6101
6102 - def RemoveGeometry(self, *args):
6103 """RemoveGeometry(Geometry self, int iSubGeom) -> OGRErr""" 6104 return _ogr.Geometry_RemoveGeometry(self, *args)
6105 6106
6107 - def Clone(self, *args):
6108 """ 6109 Clone(Geometry self) -> Geometry 6110 6111 OGRGeometryH OGR_G_Clone(OGRGeometryH 6112 hGeom) 6113 6114 Make a copy of this object. 6115 6116 This function relates to the SFCOM IGeometry::clone() method. 6117 6118 This function is the same as the CPP method OGRGeometry::clone(). 6119 6120 Parameters: 6121 ----------- 6122 6123 hGeom: handle on the geometry to clone from. 6124 6125 a handle on the copy of the geometry with the spatial reference 6126 system as the original. 6127 """ 6128 return _ogr.Geometry_Clone(self, *args)
6129 6130
6131 - def GetGeometryType(self, *args):
6132 """ 6133 GetGeometryType(Geometry self) -> OGRwkbGeometryType 6134 6135 OGRwkbGeometryType 6136 OGR_G_GetGeometryType(OGRGeometryH hGeom) 6137 6138 Fetch geometry type. 6139 6140 Note that the geometry type may include the 2.5D flag. To get a 2D 6141 flattened version of the geometry type apply the wkbFlatten() macro to 6142 the return result. 6143 6144 This function is the same as the CPP method 6145 OGRGeometry::getGeometryType(). 6146 6147 Parameters: 6148 ----------- 6149 6150 hGeom: handle on the geometry to get type from. 6151 6152 the geometry type code. 6153 """ 6154 return _ogr.Geometry_GetGeometryType(self, *args)
6155 6156
6157 - def GetGeometryName(self, *args):
6158 """ 6159 GetGeometryName(Geometry self) -> char const * 6160 6161 const char* 6162 OGR_G_GetGeometryName(OGRGeometryH hGeom) 6163 6164 Fetch WKT name for geometry type. 6165 6166 There is no SFCOM analog to this function. 6167 6168 This function is the same as the CPP method 6169 OGRGeometry::getGeometryName(). 6170 6171 Parameters: 6172 ----------- 6173 6174 hGeom: handle on the geometry to get name from. 6175 6176 name used for this geometry type in well known text format. 6177 """ 6178 return _ogr.Geometry_GetGeometryName(self, *args)
6179 6180
6181 - def Length(self, *args):
6182 """Length(Geometry self) -> double""" 6183 return _ogr.Geometry_Length(self, *args)
6184 6185
6186 - def Area(self, *args):
6187 """Area(Geometry self) -> double""" 6188 return _ogr.Geometry_Area(self, *args)
6189 6190
6191 - def GetArea(self, *args):
6192 """GetArea(Geometry self) -> double""" 6193 return _ogr.Geometry_GetArea(self, *args)
6194 6195
6196 - def GetPointCount(self, *args):
6197 """GetPointCount(Geometry self) -> int""" 6198 return _ogr.Geometry_GetPointCount(self, *args)
6199 6200
6201 - def GetPoints(self, *args, **kwargs):
6202 """GetPoints(Geometry self, int nCoordDimension=0)""" 6203 return _ogr.Geometry_GetPoints(self, *args, **kwargs)
6204 6205
6206 - def GetX(self, *args, **kwargs):
6207 """GetX(Geometry self, int point=0) -> double""" 6208 return _ogr.Geometry_GetX(self, *args, **kwargs)
6209 6210
6211 - def GetY(self, *args, **kwargs):
6212 """GetY(Geometry self, int point=0) -> double""" 6213 return _ogr.Geometry_GetY(self, *args, **kwargs)
6214 6215
6216 - def GetZ(self, *args, **kwargs):
6217 """GetZ(Geometry self, int point=0) -> double""" 6218 return _ogr.Geometry_GetZ(self, *args, **kwargs)
6219 6220
6221 - def GetM(self, *args, **kwargs):
6222 """GetM(Geometry self, int point=0) -> double""" 6223 return _ogr.Geometry_GetM(self, *args, **kwargs)
6224 6225
6226 - def GetPoint(self, *args):
6227 """GetPoint(Geometry self, int iPoint=0)""" 6228 return _ogr.Geometry_GetPoint(self, *args)
6229 6230
6231 - def GetPointZM(self, *args):
6232 """GetPointZM(Geometry self, int iPoint=0)""" 6233 return _ogr.Geometry_GetPointZM(self, *args)
6234 6235
6236 - def GetPoint_2D(self, *args):
6237 """GetPoint_2D(Geometry self, int iPoint=0)""" 6238 return _ogr.Geometry_GetPoint_2D(self, *args)
6239 6240
6241 - def GetGeometryCount(self, *args):
6242 """GetGeometryCount(Geometry self) -> int""" 6243 return _ogr.Geometry_GetGeometryCount(self, *args)
6244 6245
6246 - def SetPoint(self, *args, **kwargs):
6247 """SetPoint(Geometry self, int point, double x, double y, double z=0)""" 6248 return _ogr.Geometry_SetPoint(self, *args, **kwargs)
6249 6250
6251 - def SetPointM(self, *args, **kwargs):
6252 """SetPointM(Geometry self, int point, double x, double y, double m)""" 6253 return _ogr.Geometry_SetPointM(self, *args, **kwargs)
6254 6255
6256 - def SetPointZM(self, *args, **kwargs):
6257 """SetPointZM(Geometry self, int point, double x, double y, double z, double m)""" 6258 return _ogr.Geometry_SetPointZM(self, *args, **kwargs)
6259 6260
6261 - def SetPoint_2D(self, *args, **kwargs):
6262 """SetPoint_2D(Geometry self, int point, double x, double y)""" 6263 return _ogr.Geometry_SetPoint_2D(self, *args, **kwargs)
6264 6265
6266 - def SwapXY(self, *args):
6267 """ 6268 SwapXY(Geometry self) 6269 6270 void OGR_G_SwapXY(OGRGeometryH hGeom) 6271 6272 Swap x and y coordinates. 6273 6274 Parameters: 6275 ----------- 6276 6277 hGeom: geometry. 6278 6279 OGR 2.3.0 6280 """ 6281 return _ogr.Geometry_SwapXY(self, *args)
6282 6283
6284 - def GetGeometryRef(self, *args):
6285 """GetGeometryRef(Geometry self, int geom) -> Geometry""" 6286 return _ogr.Geometry_GetGeometryRef(self, *args)
6287 6288
6289 - def Simplify(self, *args):
6290 """ 6291 Simplify(Geometry self, double tolerance) -> Geometry 6292 6293 OGRGeometryH 6294 OGR_G_Simplify(OGRGeometryH hThis, double dTolerance) 6295 6296 Compute a simplified geometry. 6297 6298 This function is the same as the C++ method OGRGeometry::Simplify(). 6299 6300 This function is built on the GEOS library, check it for the 6301 definition of the geometry operation. If OGR is built without the GEOS 6302 library, this function will always fail, issuing a CPLE_NotSupported 6303 error. 6304 6305 Parameters: 6306 ----------- 6307 6308 hThis: the geometry. 6309 6310 dTolerance: the distance tolerance for the simplification. 6311 6312 the simplified geometry or NULL if an error occurs. 6313 6314 OGR 1.8.0 6315 """ 6316 return _ogr.Geometry_Simplify(self, *args)
6317 6318
6319 - def SimplifyPreserveTopology(self, *args):
6320 """ 6321 SimplifyPreserveTopology(Geometry self, double tolerance) -> Geometry 6322 6323 OGRGeometryH 6324 OGR_G_SimplifyPreserveTopology(OGRGeometryH hThis, double dTolerance) 6325 6326 Simplify the geometry while preserving topology. 6327 6328 This function is the same as the C++ method 6329 OGRGeometry::SimplifyPreserveTopology(). 6330 6331 This function is built on the GEOS library, check it for the 6332 definition of the geometry operation. If OGR is built without the GEOS 6333 library, this function will always fail, issuing a CPLE_NotSupported 6334 error. 6335 6336 Parameters: 6337 ----------- 6338 6339 hThis: the geometry. 6340 6341 dTolerance: the distance tolerance for the simplification. 6342 6343 the simplified geometry or NULL if an error occurs. 6344 6345 OGR 1.9.0 6346 """ 6347 return _ogr.Geometry_SimplifyPreserveTopology(self, *args)
6348 6349
6350 - def DelaunayTriangulation(self, *args, **kwargs):
6351 """ 6352 DelaunayTriangulation(Geometry self, double dfTolerance=0.0, int bOnlyEdges=False) -> Geometry 6353 6354 OGRGeometryH 6355 OGR_G_DelaunayTriangulation(OGRGeometryH hThis, double dfTolerance, 6356 int bOnlyEdges) 6357 6358 Return a Delaunay triangulation of the vertices of the geometry. 6359 6360 This function is the same as the C++ method 6361 OGRGeometry::DelaunayTriangulation(). 6362 6363 This function is built on the GEOS library, v3.4 or above. If OGR is 6364 built without the GEOS library, this function will always fail, 6365 issuing a CPLE_NotSupported error. 6366 6367 Parameters: 6368 ----------- 6369 6370 hThis: the geometry. 6371 6372 dfTolerance: optional snapping tolerance to use for improved 6373 robustness 6374 6375 bOnlyEdges: if TRUE, will return a MULTILINESTRING, otherwise it will 6376 return a GEOMETRYCOLLECTION containing triangular POLYGONs. 6377 6378 the geometry resulting from the Delaunay triangulation or NULL if an 6379 error occurs. 6380 6381 OGR 2.1 6382 """ 6383 return _ogr.Geometry_DelaunayTriangulation(self, *args, **kwargs)
6384 6385
6386 - def Polygonize(self, *args):
6387 """ 6388 Polygonize(Geometry self) -> Geometry 6389 6390 OGRGeometryH 6391 OGR_G_Polygonize(OGRGeometryH hTarget) 6392 6393 Polygonizes a set of sparse edges. 6394 6395 A new geometry object is created and returned containing a collection 6396 of reassembled Polygons: NULL will be returned if the input collection 6397 doesn't corresponds to a MultiLinestring, or when reassembling Edges 6398 into Polygons is impossible due to topological inconsistencies. 6399 6400 This function is the same as the C++ method OGRGeometry::Polygonize(). 6401 6402 This function is built on the GEOS library, check it for the 6403 definition of the geometry operation. If OGR is built without the GEOS 6404 library, this function will always fail, issuing a CPLE_NotSupported 6405 error. 6406 6407 Parameters: 6408 ----------- 6409 6410 hTarget: The Geometry to be polygonized. 6411 6412 a handle to a newly allocated geometry now owned by the caller, or 6413 NULL on failure. 6414 6415 OGR 1.9.0 6416 """ 6417 return _ogr.Geometry_Polygonize(self, *args)
6418 6419
6420 - def Boundary(self, *args):
6421 """ 6422 Boundary(Geometry self) -> Geometry 6423 6424 OGRGeometryH 6425 OGR_G_Boundary(OGRGeometryH hTarget) 6426 6427 Compute boundary. 6428 6429 A new geometry object is created and returned containing the boundary 6430 of the geometry on which the method is invoked. 6431 6432 This function is the same as the C++ method OGR_G_Boundary(). 6433 6434 This function is built on the GEOS library, check it for the 6435 definition of the geometry operation. If OGR is built without the GEOS 6436 library, this function will always fail, issuing a CPLE_NotSupported 6437 error. 6438 6439 Parameters: 6440 ----------- 6441 6442 hTarget: The Geometry to calculate the boundary of. 6443 6444 a handle to a newly allocated geometry now owned by the caller, or 6445 NULL on failure. 6446 6447 OGR 1.8.0 6448 """ 6449 return _ogr.Geometry_Boundary(self, *args)
6450 6451
6452 - def GetBoundary(self, *args):
6453 """ 6454 GetBoundary(Geometry self) -> Geometry 6455 6456 OGRGeometryH 6457 OGR_G_GetBoundary(OGRGeometryH hTarget) 6458 6459 Compute boundary (deprecated) 6460 6461 Deprecated 6462 6463 See: OGR_G_Boundary() 6464 """ 6465 return _ogr.Geometry_GetBoundary(self, *args)
6466 6467
6468 - def ConvexHull(self, *args):
6469 """ 6470 ConvexHull(Geometry self) -> Geometry 6471 6472 OGRGeometryH 6473 OGR_G_ConvexHull(OGRGeometryH hTarget) 6474 6475 Compute convex hull. 6476 6477 A new geometry object is created and returned containing the convex 6478 hull of the geometry on which the method is invoked. 6479 6480 This function is the same as the C++ method OGRGeometry::ConvexHull(). 6481 6482 This function is built on the GEOS library, check it for the 6483 definition of the geometry operation. If OGR is built without the GEOS 6484 library, this function will always fail, issuing a CPLE_NotSupported 6485 error. 6486 6487 Parameters: 6488 ----------- 6489 6490 hTarget: The Geometry to calculate the convex hull of. 6491 6492 a handle to a newly allocated geometry now owned by the caller, or 6493 NULL on failure. 6494 """ 6495 return _ogr.Geometry_ConvexHull(self, *args)
6496 6497
6498 - def MakeValid(self, *args):
6499 """ 6500 MakeValid(Geometry self) -> Geometry 6501 6502 OGRGeometryH 6503 OGR_G_MakeValid(OGRGeometryH hGeom) 6504 6505 Attempts to make an invalid geometry valid without losing vertices. 6506 6507 Already-valid geometries are cloned without further intervention. 6508 6509 This function is the same as the C++ method OGRGeometry::MakeValid(). 6510 6511 This function is built on the GEOS >= 3.8 library, check it for the 6512 definition of the geometry operation. If OGR is built without the GEOS 6513 >= 3.8 library, this function will return a clone of the input 6514 geometry if it is valid, or NULL if it is invalid 6515 6516 Parameters: 6517 ----------- 6518 6519 hGeom: The Geometry to make valid. 6520 6521 a newly allocated geometry now owned by the caller, or NULL on 6522 failure. 6523 6524 GDAL 3.0 6525 """ 6526 return _ogr.Geometry_MakeValid(self, *args)
6527 6528
6529 - def RemoveLowerDimensionSubGeoms(self, *args):
6530 """RemoveLowerDimensionSubGeoms(Geometry self) -> Geometry""" 6531 return _ogr.Geometry_RemoveLowerDimensionSubGeoms(self, *args)
6532 6533
6534 - def Buffer(self, *args, **kwargs):
6535 """ 6536 Buffer(Geometry self, double distance, int quadsecs=30) -> Geometry 6537 6538 OGRGeometryH OGR_G_Buffer(OGRGeometryH 6539 hTarget, double dfDist, int nQuadSegs) 6540 6541 Compute buffer of geometry. 6542 6543 Builds a new geometry containing the buffer region around the geometry 6544 on which it is invoked. The buffer is a polygon containing the region 6545 within the buffer distance of the original geometry. 6546 6547 Some buffer sections are properly described as curves, but are 6548 converted to approximate polygons. The nQuadSegs parameter can be used 6549 to control how many segments should be used to define a 90 degree 6550 curve - a quadrant of a circle. A value of 30 is a reasonable default. 6551 Large values result in large numbers of vertices in the resulting 6552 buffer geometry while small numbers reduce the accuracy of the result. 6553 6554 This function is the same as the C++ method OGRGeometry::Buffer(). 6555 6556 This function is built on the GEOS library, check it for the 6557 definition of the geometry operation. If OGR is built without the GEOS 6558 library, this function will always fail, issuing a CPLE_NotSupported 6559 error. 6560 6561 Parameters: 6562 ----------- 6563 6564 hTarget: the geometry. 6565 6566 dfDist: the buffer distance to be applied. Should be expressed into 6567 the same unit as the coordinates of the geometry. 6568 6569 nQuadSegs: the number of segments used to approximate a 90 degree 6570 (quadrant) of curvature. 6571 6572 the newly created geometry, or NULL if an error occurs. 6573 """ 6574 return _ogr.Geometry_Buffer(self, *args, **kwargs)
6575 6576
6577 - def Intersection(self, *args):
6578 """ 6579 Intersection(Geometry self, Geometry other) -> Geometry 6580 6581 OGRGeometryH 6582 OGR_G_Intersection(OGRGeometryH hThis, OGRGeometryH hOther) 6583 6584 Compute intersection. 6585 6586 Generates a new geometry which is the region of intersection of the 6587 two geometries operated on. The OGR_G_Intersects() function can be 6588 used to test if two geometries intersect. 6589 6590 Geometry validity is not checked. In case you are unsure of the 6591 validity of the input geometries, call IsValid() before, otherwise the 6592 result might be wrong. 6593 6594 This function is the same as the C++ method 6595 OGRGeometry::Intersection(). 6596 6597 This function is built on the GEOS library, check it for the 6598 definition of the geometry operation. If OGR is built without the GEOS 6599 library, this function will always fail, issuing a CPLE_NotSupported 6600 error. 6601 6602 Parameters: 6603 ----------- 6604 6605 hThis: the geometry. 6606 6607 hOther: the other geometry. 6608 6609 a new geometry representing the intersection or NULL if there is no 6610 intersection or an error occurs. 6611 """ 6612 return _ogr.Geometry_Intersection(self, *args)
6613 6614
6615 - def Union(self, *args):
6616 """ 6617 Union(Geometry self, Geometry other) -> Geometry 6618 6619 OGRGeometryH OGR_G_Union(OGRGeometryH 6620 hThis, OGRGeometryH hOther) 6621 6622 Compute union. 6623 6624 Generates a new geometry which is the region of union of the two 6625 geometries operated on. 6626 6627 Geometry validity is not checked. In case you are unsure of the 6628 validity of the input geometries, call IsValid() before, otherwise the 6629 result might be wrong. 6630 6631 This function is the same as the C++ method OGRGeometry::Union(). 6632 6633 This function is built on the GEOS library, check it for the 6634 definition of the geometry operation. If OGR is built without the GEOS 6635 library, this function will always fail, issuing a CPLE_NotSupported 6636 error. 6637 6638 Parameters: 6639 ----------- 6640 6641 hThis: the geometry. 6642 6643 hOther: the other geometry. 6644 6645 a new geometry representing the union or NULL if an error occurs. 6646 """ 6647 return _ogr.Geometry_Union(self, *args)
6648 6649
6650 - def UnionCascaded(self, *args):
6651 """ 6652 UnionCascaded(Geometry self) -> Geometry 6653 6654 OGRGeometryH 6655 OGR_G_UnionCascaded(OGRGeometryH hThis) 6656 6657 Compute union using cascading. 6658 6659 Geometry validity is not checked. In case you are unsure of the 6660 validity of the input geometries, call IsValid() before, otherwise the 6661 result might be wrong. 6662 6663 This function is the same as the C++ method 6664 OGRGeometry::UnionCascaded(). 6665 6666 This function is built on the GEOS library, check it for the 6667 definition of the geometry operation. If OGR is built without the GEOS 6668 library, this function will always fail, issuing a CPLE_NotSupported 6669 error. 6670 6671 Parameters: 6672 ----------- 6673 6674 hThis: the geometry. 6675 6676 a new geometry representing the union or NULL if an error occurs. 6677 """ 6678 return _ogr.Geometry_UnionCascaded(self, *args)
6679 6680
6681 - def Difference(self, *args):
6682 """ 6683 Difference(Geometry self, Geometry other) -> Geometry 6684 6685 OGRGeometryH 6686 OGR_G_Difference(OGRGeometryH hThis, OGRGeometryH hOther) 6687 6688 Compute difference. 6689 6690 Generates a new geometry which is the region of this geometry with the 6691 region of the other geometry removed. 6692 6693 Geometry validity is not checked. In case you are unsure of the 6694 validity of the input geometries, call IsValid() before, otherwise the 6695 result might be wrong. 6696 6697 This function is the same as the C++ method OGRGeometry::Difference(). 6698 6699 This function is built on the GEOS library, check it for the 6700 definition of the geometry operation. If OGR is built without the GEOS 6701 library, this function will always fail, issuing a CPLE_NotSupported 6702 error. 6703 6704 Parameters: 6705 ----------- 6706 6707 hThis: the geometry. 6708 6709 hOther: the other geometry. 6710 6711 a new geometry representing the difference or NULL if the difference 6712 is empty or an error occurs. 6713 """ 6714 return _ogr.Geometry_Difference(self, *args)
6715 6716
6717 - def SymDifference(self, *args):
6718 """ 6719 SymDifference(Geometry self, Geometry other) -> Geometry 6720 6721 OGRGeometryH 6722 OGR_G_SymDifference(OGRGeometryH hThis, OGRGeometryH hOther) 6723 6724 Compute symmetric difference. 6725 6726 Generates a new geometry which is the symmetric difference of this 6727 geometry and the other geometry. 6728 6729 Geometry validity is not checked. In case you are unsure of the 6730 validity of the input geometries, call IsValid() before, otherwise the 6731 result might be wrong. 6732 6733 This function is the same as the C++ method 6734 OGRGeometry::SymmetricDifference(). 6735 6736 This function is built on the GEOS library, check it for the 6737 definition of the geometry operation. If OGR is built without the GEOS 6738 library, this function will always fail, issuing a CPLE_NotSupported 6739 error. 6740 6741 Parameters: 6742 ----------- 6743 6744 hThis: the geometry. 6745 6746 hOther: the other geometry. 6747 6748 a new geometry representing the symmetric difference or NULL if the 6749 difference is empty or an error occurs. 6750 6751 OGR 1.8.0 6752 """ 6753 return _ogr.Geometry_SymDifference(self, *args)
6754 6755
6756 - def SymmetricDifference(self, *args):
6757 """ 6758 SymmetricDifference(Geometry self, Geometry other) -> Geometry 6759 6760 OGRGeometryH 6761 OGR_G_SymmetricDifference(OGRGeometryH hThis, OGRGeometryH hOther) 6762 6763 Compute symmetric difference (deprecated) 6764 6765 Deprecated 6766 6767 See: OGR_G_SymmetricDifference() 6768 """ 6769 return _ogr.Geometry_SymmetricDifference(self, *args)
6770 6771
6772 - def Distance(self, *args):
6773 """ 6774 Distance(Geometry self, Geometry other) -> double 6775 6776 double OGR_G_Distance(OGRGeometryH 6777 hFirst, OGRGeometryH hOther) 6778 6779 Compute distance between two geometries. 6780 6781 Returns the shortest distance between the two geometries. The distance 6782 is expressed into the same unit as the coordinates of the geometries. 6783 6784 This function is the same as the C++ method OGRGeometry::Distance(). 6785 6786 This function is built on the GEOS library, check it for the 6787 definition of the geometry operation. If OGR is built without the GEOS 6788 library, this function will always fail, issuing a CPLE_NotSupported 6789 error. 6790 6791 Parameters: 6792 ----------- 6793 6794 hFirst: the first geometry to compare against. 6795 6796 hOther: the other geometry to compare against. 6797 6798 the distance between the geometries or -1 if an error occurs. 6799 """ 6800 return _ogr.Geometry_Distance(self, *args)
6801 6802
6803 - def Distance3D(self, *args):
6804 """ 6805 Distance3D(Geometry self, Geometry other) -> double 6806 6807 double 6808 OGR_G_Distance3D(OGRGeometryH hFirst, OGRGeometryH hOther) 6809 6810 Returns the 3D distance between two geometries. 6811 6812 The distance is expressed into the same unit as the coordinates of the 6813 geometries. 6814 6815 This method is built on the SFCGAL library, check it for the 6816 definition of the geometry operation. If OGR is built without the 6817 SFCGAL library, this method will always return -1.0 6818 6819 This function is the same as the C++ method OGRGeometry::Distance3D(). 6820 6821 Parameters: 6822 ----------- 6823 6824 hFirst: the first geometry to compare against. 6825 6826 hOther: the other geometry to compare against. 6827 6828 distance between the two geometries 6829 6830 GDAL 2.2 6831 6832 the distance between the geometries or -1 if an error occurs. 6833 """ 6834 return _ogr.Geometry_Distance3D(self, *args)
6835 6836
6837 - def Empty(self, *args):
6838 """ 6839 Empty(Geometry self) 6840 6841 void OGR_G_Empty(OGRGeometryH hGeom) 6842 6843 Clear geometry information. 6844 6845 This restores the geometry to its initial state after construction, 6846 and before assignment of actual geometry. 6847 6848 This function relates to the SFCOM IGeometry::Empty() method. 6849 6850 This function is the same as the CPP method OGRGeometry::empty(). 6851 6852 Parameters: 6853 ----------- 6854 6855 hGeom: handle on the geometry to empty. 6856 """ 6857 return _ogr.Geometry_Empty(self, *args)
6858 6859
6860 - def IsEmpty(self, *args):
6861 """ 6862 IsEmpty(Geometry self) -> bool 6863 6864 int OGR_G_IsEmpty(OGRGeometryH hGeom) 6865 6866 Test if the geometry is empty. 6867 6868 This method is the same as the CPP method OGRGeometry::IsEmpty(). 6869 6870 Parameters: 6871 ----------- 6872 6873 hGeom: The Geometry to test. 6874 6875 TRUE if the geometry has no points, otherwise FALSE. 6876 """ 6877 return _ogr.Geometry_IsEmpty(self, *args)
6878 6879
6880 - def IsValid(self, *args):
6881 """ 6882 IsValid(Geometry self) -> bool 6883 6884 int OGR_G_IsValid(OGRGeometryH hGeom) 6885 6886 Test if the geometry is valid. 6887 6888 This function is the same as the C++ method OGRGeometry::IsValid(). 6889 6890 This function is built on the GEOS library, check it for the 6891 definition of the geometry operation. If OGR is built without the GEOS 6892 library, this function will always return FALSE. 6893 6894 Parameters: 6895 ----------- 6896 6897 hGeom: The Geometry to test. 6898 6899 TRUE if the geometry has no points, otherwise FALSE. 6900 """ 6901 return _ogr.Geometry_IsValid(self, *args)
6902 6903
6904 - def IsSimple(self, *args):
6905 """ 6906 IsSimple(Geometry self) -> bool 6907 6908 int OGR_G_IsSimple(OGRGeometryH 6909 hGeom) 6910 6911 Returns TRUE if the geometry is simple. 6912 6913 Returns TRUE if the geometry has no anomalous geometric points, such 6914 as self intersection or self tangency. The description of each 6915 instantiable geometric class will include the specific conditions that 6916 cause an instance of that class to be classified as not simple. 6917 6918 This function is the same as the C++ method OGRGeometry::IsSimple() 6919 method. 6920 6921 If OGR is built without the GEOS library, this function will always 6922 return FALSE. 6923 6924 Parameters: 6925 ----------- 6926 6927 hGeom: The Geometry to test. 6928 6929 TRUE if object is simple, otherwise FALSE. 6930 """ 6931 return _ogr.Geometry_IsSimple(self, *args)
6932 6933
6934 - def IsRing(self, *args):
6935 """ 6936 IsRing(Geometry self) -> bool 6937 6938 int OGR_G_IsRing(OGRGeometryH hGeom) 6939 6940 Test if the geometry is a ring. 6941 6942 This function is the same as the C++ method OGRGeometry::IsRing(). 6943 6944 This function is built on the GEOS library, check it for the 6945 definition of the geometry operation. If OGR is built without the GEOS 6946 library, this function will always return FALSE. 6947 6948 Parameters: 6949 ----------- 6950 6951 hGeom: The Geometry to test. 6952 6953 TRUE if the geometry has no points, otherwise FALSE. 6954 """ 6955 return _ogr.Geometry_IsRing(self, *args)
6956 6957
6958 - def Intersects(self, *args):
6959 """ 6960 Intersects(Geometry self, Geometry other) -> bool 6961 6962 int OGR_G_Intersects(OGRGeometryH 6963 hGeom, OGRGeometryH hOtherGeom) 6964 6965 Do these features intersect? 6966 6967 Determines whether two geometries intersect. If GEOS is enabled, then 6968 this is done in rigorous fashion otherwise TRUE is returned if the 6969 envelopes (bounding boxes) of the two geometries overlap. 6970 6971 This function is the same as the CPP method OGRGeometry::Intersects. 6972 6973 Parameters: 6974 ----------- 6975 6976 hGeom: handle on the first geometry. 6977 6978 hOtherGeom: handle on the other geometry to test against. 6979 6980 TRUE if the geometries intersect, otherwise FALSE. 6981 """ 6982 return _ogr.Geometry_Intersects(self, *args)
6983 6984
6985 - def Intersect(self, *args):
6986 """Intersect(Geometry self, Geometry other) -> bool""" 6987 return _ogr.Geometry_Intersect(self, *args)
6988 6989
6990 - def Equals(self, *args):
6991 """ 6992 Equals(Geometry self, Geometry other) -> bool 6993 6994 int OGR_G_Equals(OGRGeometryH hGeom, 6995 OGRGeometryH hOther) 6996 6997 Returns TRUE if two geometries are equivalent. 6998 6999 This operation implements the SQL/MM ST_OrderingEquals() operation. 7000 7001 The comparison is done in a structural way, that is to say that the 7002 geometry types must be identical, as well as the number and ordering 7003 of sub-geometries and vertices. Or equivalently, two geometries are 7004 considered equal by this method if their WKT/WKB representation is 7005 equal. Note: this must be distinguished for equality in a spatial way 7006 (which is the purpose of the ST_Equals() operation). 7007 7008 This function is the same as the CPP method OGRGeometry::Equals() 7009 method. 7010 7011 Parameters: 7012 ----------- 7013 7014 hGeom: handle on the first geometry. 7015 7016 hOther: handle on the other geometry to test against. 7017 7018 TRUE if equivalent or FALSE otherwise. 7019 """ 7020 return _ogr.Geometry_Equals(self, *args)
7021 7022
7023 - def Equal(self, *args):
7024 """Equal(Geometry self, Geometry other) -> bool""" 7025 return _ogr.Geometry_Equal(self, *args)
7026 7027
7028 - def Disjoint(self, *args):
7029 """ 7030 Disjoint(Geometry self, Geometry other) -> bool 7031 7032 int OGR_G_Disjoint(OGRGeometryH 7033 hThis, OGRGeometryH hOther) 7034 7035 Test for disjointness. 7036 7037 Tests if this geometry and the other geometry are disjoint. 7038 7039 Geometry validity is not checked. In case you are unsure of the 7040 validity of the input geometries, call IsValid() before, otherwise the 7041 result might be wrong. 7042 7043 This function is the same as the C++ method OGRGeometry::Disjoint(). 7044 7045 This function is built on the GEOS library, check it for the 7046 definition of the geometry operation. If OGR is built without the GEOS 7047 library, this function will always fail, issuing a CPLE_NotSupported 7048 error. 7049 7050 Parameters: 7051 ----------- 7052 7053 hThis: the geometry to compare. 7054 7055 hOther: the other geometry to compare. 7056 7057 TRUE if they are disjoint, otherwise FALSE. 7058 """ 7059 return _ogr.Geometry_Disjoint(self, *args)
7060 7061
7062 - def Touches(self, *args):
7063 """ 7064 Touches(Geometry self, Geometry other) -> bool 7065 7066 int OGR_G_Touches(OGRGeometryH hThis, 7067 OGRGeometryH hOther) 7068 7069 Test for touching. 7070 7071 Tests if this geometry and the other geometry are touching. 7072 7073 Geometry validity is not checked. In case you are unsure of the 7074 validity of the input geometries, call IsValid() before, otherwise the 7075 result might be wrong. 7076 7077 This function is the same as the C++ method OGRGeometry::Touches(). 7078 7079 This function is built on the GEOS library, check it for the 7080 definition of the geometry operation. If OGR is built without the GEOS 7081 library, this function will always fail, issuing a CPLE_NotSupported 7082 error. 7083 7084 Parameters: 7085 ----------- 7086 7087 hThis: the geometry to compare. 7088 7089 hOther: the other geometry to compare. 7090 7091 TRUE if they are touching, otherwise FALSE. 7092 """ 7093 return _ogr.Geometry_Touches(self, *args)
7094 7095
7096 - def Crosses(self, *args):
7097 """ 7098 Crosses(Geometry self, Geometry other) -> bool 7099 7100 int OGR_G_Crosses(OGRGeometryH hThis, 7101 OGRGeometryH hOther) 7102 7103 Test for crossing. 7104 7105 Tests if this geometry and the other geometry are crossing. 7106 7107 Geometry validity is not checked. In case you are unsure of the 7108 validity of the input geometries, call IsValid() before, otherwise the 7109 result might be wrong. 7110 7111 This function is the same as the C++ method OGRGeometry::Crosses(). 7112 7113 This function is built on the GEOS library, check it for the 7114 definition of the geometry operation. If OGR is built without the GEOS 7115 library, this function will always fail, issuing a CPLE_NotSupported 7116 error. 7117 7118 Parameters: 7119 ----------- 7120 7121 hThis: the geometry to compare. 7122 7123 hOther: the other geometry to compare. 7124 7125 TRUE if they are crossing, otherwise FALSE. 7126 """ 7127 return _ogr.Geometry_Crosses(self, *args)
7128 7129
7130 - def Within(self, *args):
7131 """ 7132 Within(Geometry self, Geometry other) -> bool 7133 7134 int OGR_G_Within(OGRGeometryH hThis, 7135 OGRGeometryH hOther) 7136 7137 Test for containment. 7138 7139 Tests if this geometry is within the other geometry. 7140 7141 Geometry validity is not checked. In case you are unsure of the 7142 validity of the input geometries, call IsValid() before, otherwise the 7143 result might be wrong. 7144 7145 This function is the same as the C++ method OGRGeometry::Within(). 7146 7147 This function is built on the GEOS library, check it for the 7148 definition of the geometry operation. If OGR is built without the GEOS 7149 library, this function will always fail, issuing a CPLE_NotSupported 7150 error. 7151 7152 Parameters: 7153 ----------- 7154 7155 hThis: the geometry to compare. 7156 7157 hOther: the other geometry to compare. 7158 7159 TRUE if hThis is within hOther, otherwise FALSE. 7160 """ 7161 return _ogr.Geometry_Within(self, *args)
7162 7163
7164 - def Contains(self, *args):
7165 """ 7166 Contains(Geometry self, Geometry other) -> bool 7167 7168 int OGR_G_Contains(OGRGeometryH 7169 hThis, OGRGeometryH hOther) 7170 7171 Test for containment. 7172 7173 Tests if this geometry contains the other geometry. 7174 7175 Geometry validity is not checked. In case you are unsure of the 7176 validity of the input geometries, call IsValid() before, otherwise the 7177 result might be wrong. 7178 7179 This function is the same as the C++ method OGRGeometry::Contains(). 7180 7181 This function is built on the GEOS library, check it for the 7182 definition of the geometry operation. If OGR is built without the GEOS 7183 library, this function will always fail, issuing a CPLE_NotSupported 7184 error. 7185 7186 Parameters: 7187 ----------- 7188 7189 hThis: the geometry to compare. 7190 7191 hOther: the other geometry to compare. 7192 7193 TRUE if hThis contains hOther geometry, otherwise FALSE. 7194 """ 7195 return _ogr.Geometry_Contains(self, *args)
7196 7197
7198 - def Overlaps(self, *args):
7199 """ 7200 Overlaps(Geometry self, Geometry other) -> bool 7201 7202 int OGR_G_Overlaps(OGRGeometryH 7203 hThis, OGRGeometryH hOther) 7204 7205 Test for overlap. 7206 7207 Tests if this geometry and the other geometry overlap, that is their 7208 intersection has a non-zero area. 7209 7210 Geometry validity is not checked. In case you are unsure of the 7211 validity of the input geometries, call IsValid() before, otherwise the 7212 result might be wrong. 7213 7214 This function is the same as the C++ method OGRGeometry::Overlaps(). 7215 7216 This function is built on the GEOS library, check it for the 7217 definition of the geometry operation. If OGR is built without the GEOS 7218 library, this function will always fail, issuing a CPLE_NotSupported 7219 error. 7220 7221 Parameters: 7222 ----------- 7223 7224 hThis: the geometry to compare. 7225 7226 hOther: the other geometry to compare. 7227 7228 TRUE if they are overlapping, otherwise FALSE. 7229 """ 7230 return _ogr.Geometry_Overlaps(self, *args)
7231 7232
7233 - def TransformTo(self, *args):
7234 """ 7235 TransformTo(Geometry self, SpatialReference reference) -> OGRErr 7236 7237 OGRErr 7238 OGR_G_TransformTo(OGRGeometryH hGeom, OGRSpatialReferenceH hSRS) 7239 7240 Transform geometry to new spatial reference system. 7241 7242 This function will transform the coordinates of a geometry from their 7243 current spatial reference system to a new target spatial reference 7244 system. Normally this means reprojecting the vectors, but it could 7245 include datum shifts, and changes of units. 7246 7247 This function will only work if the geometry already has an assigned 7248 spatial reference system, and if it is transformable to the target 7249 coordinate system. 7250 7251 Because this function requires internal creation and initialization of 7252 an OGRCoordinateTransformation object it is significantly more 7253 expensive to use this function to transform many geometries than it is 7254 to create the OGRCoordinateTransformation in advance, and call 7255 transform() with that transformation. This function exists primarily 7256 for convenience when only transforming a single geometry. 7257 7258 This function is the same as the CPP method OGRGeometry::transformTo. 7259 7260 Parameters: 7261 ----------- 7262 7263 hGeom: handle on the geometry to apply the transform to. 7264 7265 hSRS: handle on the spatial reference system to apply. 7266 7267 OGRERR_NONE on success, or an error code. 7268 """ 7269 return _ogr.Geometry_TransformTo(self, *args)
7270 7271
7272 - def GetSpatialReference(self, *args):
7273 """ 7274 GetSpatialReference(Geometry self) -> SpatialReference 7275 7276 OGRSpatialReferenceH 7277 OGR_G_GetSpatialReference(OGRGeometryH hGeom) 7278 7279 Returns spatial reference system for geometry. 7280 7281 This function relates to the SFCOM IGeometry::get_SpatialReference() 7282 method. 7283 7284 This function is the same as the CPP method 7285 OGRGeometry::getSpatialReference(). 7286 7287 Parameters: 7288 ----------- 7289 7290 hGeom: handle on the geometry to get spatial reference from. 7291 7292 a reference to the spatial reference geometry. 7293 """ 7294 return _ogr.Geometry_GetSpatialReference(self, *args)
7295 7296
7297 - def AssignSpatialReference(self, *args):
7298 """ 7299 AssignSpatialReference(Geometry self, SpatialReference reference) 7300 7301 void 7302 OGR_G_AssignSpatialReference(OGRGeometryH hGeom, OGRSpatialReferenceH 7303 hSRS) 7304 7305 Assign spatial reference to this object. 7306 7307 Any existing spatial reference is replaced, but under no circumstances 7308 does this result in the object being reprojected. It is just changing 7309 the interpretation of the existing geometry. Note that assigning a 7310 spatial reference increments the reference count on the 7311 OGRSpatialReference, but does not copy it. 7312 7313 Starting with GDAL 2.3, this will also assign the spatial reference to 7314 potential sub-geometries of the geometry ( OGRGeometryCollection, 7315 OGRCurvePolygon/OGRPolygon, OGRCompoundCurve, OGRPolyhedralSurface and 7316 their derived classes). 7317 7318 This is similar to the SFCOM IGeometry::put_SpatialReference() method. 7319 7320 This function is the same as the CPP method 7321 OGRGeometry::assignSpatialReference. 7322 7323 Parameters: 7324 ----------- 7325 7326 hGeom: handle on the geometry to apply the new spatial reference 7327 system. 7328 7329 hSRS: handle on the new spatial reference system to apply. 7330 """ 7331 return _ogr.Geometry_AssignSpatialReference(self, *args)
7332 7333
7334 - def CloseRings(self, *args):
7335 """ 7336 CloseRings(Geometry self) 7337 7338 void OGR_G_CloseRings(OGRGeometryH 7339 hGeom) 7340 7341 Force rings to be closed. 7342 7343 If this geometry, or any contained geometries has polygon rings that 7344 are not closed, they will be closed by adding the starting point at 7345 the end. 7346 7347 Parameters: 7348 ----------- 7349 7350 hGeom: handle to the geometry. 7351 """ 7352 return _ogr.Geometry_CloseRings(self, *args)
7353 7354
7355 - def FlattenTo2D(self, *args):
7356 """ 7357 FlattenTo2D(Geometry self) 7358 7359 void 7360 OGR_G_FlattenTo2D(OGRGeometryH hGeom) 7361 7362 Convert geometry to strictly 2D. 7363 7364 In a sense this converts all Z coordinates to 0.0. 7365 7366 This function is the same as the CPP method 7367 OGRGeometry::flattenTo2D(). 7368 7369 Parameters: 7370 ----------- 7371 7372 hGeom: handle on the geometry to convert. 7373 """ 7374 return _ogr.Geometry_FlattenTo2D(self, *args)
7375 7376
7377 - def Segmentize(self, *args):
7378 """ 7379 Segmentize(Geometry self, double dfMaxLength) 7380 7381 void OGR_G_Segmentize(OGRGeometryH 7382 hGeom, double dfMaxLength) 7383 7384 Modify the geometry such it has no segment longer then the given 7385 distance. 7386 7387 Interpolated points will have Z and M values (if needed) set to 0. 7388 Distance computation is performed in 2d only. 7389 7390 This function is the same as the CPP method OGRGeometry::segmentize(). 7391 7392 Parameters: 7393 ----------- 7394 7395 hGeom: handle on the geometry to segmentize 7396 7397 dfMaxLength: the maximum distance between 2 points after 7398 segmentization 7399 """ 7400 return _ogr.Geometry_Segmentize(self, *args)
7401 7402
7403 - def GetEnvelope(self, *args):
7404 """ 7405 GetEnvelope(Geometry self) 7406 7407 void 7408 OGR_G_GetEnvelope(OGRGeometryH hGeom, OGREnvelope *psEnvelope) 7409 7410 Computes and returns the bounding envelope for this geometry in the 7411 passed psEnvelope structure. 7412 7413 This function is the same as the CPP method 7414 OGRGeometry::getEnvelope(). 7415 7416 Parameters: 7417 ----------- 7418 7419 hGeom: handle of the geometry to get envelope from. 7420 7421 psEnvelope: the structure in which to place the results. 7422 """ 7423 return _ogr.Geometry_GetEnvelope(self, *args)
7424 7425
7426 - def GetEnvelope3D(self, *args):
7427 """ 7428 GetEnvelope3D(Geometry self) 7429 7430 void 7431 OGR_G_GetEnvelope3D(OGRGeometryH hGeom, OGREnvelope3D *psEnvelope) 7432 7433 Computes and returns the bounding envelope (3D) for this geometry in 7434 the passed psEnvelope structure. 7435 7436 This function is the same as the CPP method 7437 OGRGeometry::getEnvelope(). 7438 7439 Parameters: 7440 ----------- 7441 7442 hGeom: handle of the geometry to get envelope from. 7443 7444 psEnvelope: the structure in which to place the results. 7445 7446 OGR 1.9.0 7447 """ 7448 return _ogr.Geometry_GetEnvelope3D(self, *args)
7449 7450
7451 - def Centroid(self, *args):
7452 """ 7453 Centroid(Geometry self) -> Geometry 7454 7455 int OGR_G_Centroid(OGRGeometryH 7456 hGeom, OGRGeometryH hCentroidPoint) 7457 7458 Compute the geometry centroid. 7459 7460 The centroid location is applied to the passed in OGRPoint object. The 7461 centroid is not necessarily within the geometry. 7462 7463 This method relates to the SFCOM ISurface::get_Centroid() method 7464 however the current implementation based on GEOS can operate on other 7465 geometry types such as multipoint, linestring, geometrycollection such 7466 as multipolygons. OGC SF SQL 1.1 defines the operation for surfaces 7467 (polygons). SQL/MM-Part 3 defines the operation for surfaces and 7468 multisurfaces (multipolygons). 7469 7470 This function is the same as the C++ method OGRGeometry::Centroid(). 7471 7472 This function is built on the GEOS library, check it for the 7473 definition of the geometry operation. If OGR is built without the GEOS 7474 library, this function will always fail, issuing a CPLE_NotSupported 7475 error. 7476 7477 OGRERR_NONE on success or OGRERR_FAILURE on error. 7478 """ 7479 return _ogr.Geometry_Centroid(self, *args)
7480 7481
7482 - def PointOnSurface(self, *args):
7483 """ 7484 PointOnSurface(Geometry self) -> Geometry 7485 7486 OGRGeometryH 7487 OGR_G_PointOnSurface(OGRGeometryH hGeom) 7488 7489 Returns a point guaranteed to lie on the surface. 7490 7491 This method relates to the SFCOM ISurface::get_PointOnSurface() method 7492 however the current implementation based on GEOS can operate on other 7493 geometry types than the types that are supported by SQL/MM-Part 3 : 7494 surfaces (polygons) and multisurfaces (multipolygons). 7495 7496 This method is built on the GEOS library, check it for the definition 7497 of the geometry operation. If OGR is built without the GEOS library, 7498 this method will always fail, issuing a CPLE_NotSupported error. 7499 7500 Parameters: 7501 ----------- 7502 7503 hGeom: the geometry to operate on. 7504 7505 a point guaranteed to lie on the surface or NULL if an error occurred. 7506 7507 OGR 1.10 7508 """ 7509 return _ogr.Geometry_PointOnSurface(self, *args)
7510 7511
7512 - def WkbSize(self, *args):
7513 """ 7514 WkbSize(Geometry self) -> int 7515 7516 int OGR_G_WkbSize(OGRGeometryH hGeom) 7517 7518 Returns size of related binary representation. 7519 7520 This function returns the exact number of bytes required to hold the 7521 well known binary representation of this geometry object. Its 7522 computation may be slightly expensive for complex geometries. 7523 7524 This function relates to the SFCOM IWks::WkbSize() method. 7525 7526 This function is the same as the CPP method OGRGeometry::WkbSize(). 7527 7528 Parameters: 7529 ----------- 7530 7531 hGeom: handle on the geometry to get the binary size from. 7532 7533 size of binary representation in bytes. 7534 """ 7535 return _ogr.Geometry_WkbSize(self, *args)
7536 7537
7538 - def GetCoordinateDimension(self, *args):
7539 """ 7540 GetCoordinateDimension(Geometry self) -> int 7541 7542 int 7543 OGR_G_GetCoordinateDimension(OGRGeometryH hGeom) 7544 7545 Get the dimension of the coordinates in this geometry. 7546 7547 This function is the same as the CPP method 7548 OGRGeometry::getCoordinateDimension(). 7549 7550 Parameters: 7551 ----------- 7552 7553 hGeom: handle on the geometry to get the dimension of the coordinates 7554 from. 7555 7556 Deprecated use OGR_G_CoordinateDimension(), OGR_G_Is3D(), or 7557 OGR_G_IsMeasured(). 7558 7559 this will return 2 or 3. 7560 """ 7561 return _ogr.Geometry_GetCoordinateDimension(self, *args)
7562 7563
7564 - def CoordinateDimension(self, *args):
7565 """ 7566 CoordinateDimension(Geometry self) -> int 7567 7568 int 7569 OGR_G_CoordinateDimension(OGRGeometryH hGeom) 7570 7571 Get the dimension of the coordinates in this geometry. 7572 7573 This function is the same as the CPP method 7574 OGRGeometry::CoordinateDimension(). 7575 7576 Parameters: 7577 ----------- 7578 7579 hGeom: handle on the geometry to get the dimension of the coordinates 7580 from. 7581 7582 this will return 2 for XY, 3 for XYZ and XYM, and 4 for XYZM data. 7583 7584 GDAL 2.1 7585 """ 7586 return _ogr.Geometry_CoordinateDimension(self, *args)
7587 7588
7589 - def Is3D(self, *args):
7590 """ 7591 Is3D(Geometry self) -> int 7592 7593 int OGR_G_Is3D(OGRGeometryH hGeom) 7594 7595 See whether this geometry has Z coordinates. 7596 7597 This function is the same as the CPP method OGRGeometry::Is3D(). 7598 7599 Parameters: 7600 ----------- 7601 7602 hGeom: handle on the geometry to check whether it has Z coordinates. 7603 7604 TRUE if the geometry has Z coordinates. 7605 7606 GDAL 2.1 7607 """ 7608 return _ogr.Geometry_Is3D(self, *args)
7609 7610
7611 - def IsMeasured(self, *args):
7612 """ 7613 IsMeasured(Geometry self) -> int 7614 7615 int OGR_G_IsMeasured(OGRGeometryH 7616 hGeom) 7617 7618 See whether this geometry is measured. 7619 7620 This function is the same as the CPP method OGRGeometry::IsMeasured(). 7621 7622 Parameters: 7623 ----------- 7624 7625 hGeom: handle on the geometry to check whether it is measured. 7626 7627 TRUE if the geometry has M coordinates. 7628 7629 GDAL 2.1 7630 """ 7631 return _ogr.Geometry_IsMeasured(self, *args)
7632 7633
7634 - def SetCoordinateDimension(self, *args):
7635 """ 7636 SetCoordinateDimension(Geometry self, int dimension) 7637 7638 void 7639 OGR_G_SetCoordinateDimension(OGRGeometryH hGeom, int nNewDimension) 7640 7641 Set the coordinate dimension. 7642 7643 This method sets the explicit coordinate dimension. Setting the 7644 coordinate dimension of a geometry to 2 should zero out any existing Z 7645 values. Setting the dimension of a geometry collection, a compound 7646 curve, a polygon, etc. will affect the children geometries. This will 7647 also remove the M dimension if present before this call. 7648 7649 Deprecated use OGR_G_Set3D() or OGR_G_SetMeasured(). 7650 7651 Parameters: 7652 ----------- 7653 7654 hGeom: handle on the geometry to set the dimension of the 7655 coordinates. 7656 7657 nNewDimension: New coordinate dimension value, either 2 or 3. 7658 """ 7659 return _ogr.Geometry_SetCoordinateDimension(self, *args)
7660 7661
7662 - def Set3D(self, *args):
7663 """ 7664 Set3D(Geometry self, int b3D) 7665 7666 void OGR_G_Set3D(OGRGeometryH hGeom, 7667 int bIs3D) 7668 7669 Add or remove the Z coordinate dimension. 7670 7671 This method adds or removes the explicit Z coordinate dimension. 7672 Removing the Z coordinate dimension of a geometry will remove any 7673 existing Z values. Adding the Z dimension to a geometry collection, a 7674 compound curve, a polygon, etc. will affect the children geometries. 7675 7676 Parameters: 7677 ----------- 7678 7679 hGeom: handle on the geometry to set or unset the Z dimension. 7680 7681 bIs3D: Should the geometry have a Z dimension, either TRUE or FALSE. 7682 7683 GDAL 2.1 7684 """ 7685 return _ogr.Geometry_Set3D(self, *args)
7686 7687
7688 - def SetMeasured(self, *args):
7689 """ 7690 SetMeasured(Geometry self, int bMeasured) 7691 7692 void 7693 OGR_G_SetMeasured(OGRGeometryH hGeom, int bIsMeasured) 7694 7695 Add or remove the M coordinate dimension. 7696 7697 This method adds or removes the explicit M coordinate dimension. 7698 Removing the M coordinate dimension of a geometry will remove any 7699 existing M values. Adding the M dimension to a geometry collection, a 7700 compound curve, a polygon, etc. will affect the children geometries. 7701 7702 Parameters: 7703 ----------- 7704 7705 hGeom: handle on the geometry to set or unset the M dimension. 7706 7707 bIsMeasured: Should the geometry have a M dimension, either TRUE or 7708 FALSE. 7709 7710 GDAL 2.1 7711 """ 7712 return _ogr.Geometry_SetMeasured(self, *args)
7713 7714
7715 - def GetDimension(self, *args):
7716 """ 7717 GetDimension(Geometry self) -> int 7718 7719 int 7720 OGR_G_GetDimension(OGRGeometryH hGeom) 7721 7722 Get the dimension of this geometry. 7723 7724 This function corresponds to the SFCOM IGeometry::GetDimension() 7725 method. It indicates the dimension of the geometry, but does not 7726 indicate the dimension of the underlying space (as indicated by 7727 OGR_G_GetCoordinateDimension() function). 7728 7729 This function is the same as the CPP method 7730 OGRGeometry::getDimension(). 7731 7732 Parameters: 7733 ----------- 7734 7735 hGeom: handle on the geometry to get the dimension from. 7736 7737 0 for points, 1 for lines and 2 for surfaces. 7738 """ 7739 return _ogr.Geometry_GetDimension(self, *args)
7740 7741
7742 - def HasCurveGeometry(self, *args):
7743 """HasCurveGeometry(Geometry self, int bLookForCircular=False) -> int""" 7744 return _ogr.Geometry_HasCurveGeometry(self, *args)
7745 7746
7747 - def GetLinearGeometry(self, *args, **kwargs):
7748 """GetLinearGeometry(Geometry self, double dfMaxAngleStepSizeDegrees=0.0, char ** options=None) -> Geometry""" 7749 return _ogr.Geometry_GetLinearGeometry(self, *args, **kwargs)
7750 7751
7752 - def GetCurveGeometry(self, *args, **kwargs):
7753 """GetCurveGeometry(Geometry self, char ** options=None) -> Geometry""" 7754 return _ogr.Geometry_GetCurveGeometry(self, *args, **kwargs)
7755 7756
7757 - def Value(self, *args):
7758 """Value(Geometry self, double dfDistance) -> Geometry""" 7759 return _ogr.Geometry_Value(self, *args)
7760 7761
7762 - def Transform(self, *args):
7763 """ 7764 Transform(Geometry self, CoordinateTransformation trans) -> OGRErr 7765 Transform(Geometry self, GeomTransformer transformer) -> Geometry 7766 7767 OGRErr OGR_G_Transform(OGRGeometryH 7768 hGeom, OGRCoordinateTransformationH hTransform) 7769 7770 Apply arbitrary coordinate transformation to geometry. 7771 7772 This function will transform the coordinates of a geometry from their 7773 current spatial reference system to a new target spatial reference 7774 system. Normally this means reprojecting the vectors, but it could 7775 include datum shifts, and changes of units. 7776 7777 Note that this function does not require that the geometry already 7778 have a spatial reference system. It will be assumed that they can be 7779 treated as having the source spatial reference system of the 7780 OGRCoordinateTransformation object, and the actual SRS of the geometry 7781 will be ignored. On successful completion the output 7782 OGRSpatialReference of the OGRCoordinateTransformation will be 7783 assigned to the geometry. 7784 7785 This function is the same as the CPP method OGRGeometry::transform. 7786 7787 Parameters: 7788 ----------- 7789 7790 hGeom: handle on the geometry to apply the transform to. 7791 7792 hTransform: handle on the transformation to apply. 7793 7794 OGRERR_NONE on success or an error code. 7795 """ 7796 return _ogr.Geometry_Transform(self, *args)
7797 7798
7799 - def Destroy(self):
7800 self.__swig_destroy__(self) 7801 self.__del__() 7802 self.thisown = 0
7803
7804 - def __str__(self):
7805 return self.ExportToWkt()
7806 7807
7808 - def __reduce__(self):
7809 return (self.__class__, (), self.ExportToWkb())
7810
7811 - def __setstate__(self, state):
7812 result = CreateGeometryFromWkb(state) 7813 self.this = result.this
7814
7815 - def __iter__(self):
7816 for i in range(self.GetGeometryCount()): 7817 yield self.GetGeometryRef(i)
7818 7819 7820 Geometry_swigregister = _ogr.Geometry_swigregister 7821 Geometry_swigregister(Geometry) 7822
7823 -class GeomTransformer(_object):
7824 """Proxy of C++ OGRGeomTransformerShadow class.""" 7825 7826 __swig_setmethods__ = {} 7827 __setattr__ = lambda self, name, value: _swig_setattr(self, GeomTransformer, name, value) 7828 __swig_getmethods__ = {} 7829 __getattr__ = lambda self, name: _swig_getattr(self, GeomTransformer, name) 7830 __repr__ = _swig_repr 7831
7832 - def __init__(self, *args):
7833 """__init__(OGRGeomTransformerShadow self, CoordinateTransformation ct, char ** options=None) -> GeomTransformer""" 7834 this = _ogr.new_GeomTransformer(*args) 7835 try: 7836 self.this.append(this) 7837 except __builtin__.Exception: 7838 self.this = this
7839 __swig_destroy__ = _ogr.delete_GeomTransformer 7840 __del__ = lambda self: None 7841
7842 - def Transform(self, *args):
7843 """Transform(GeomTransformer self, Geometry src_geom) -> Geometry""" 7844 return _ogr.GeomTransformer_Transform(self, *args)
7845 7846 GeomTransformer_swigregister = _ogr.GeomTransformer_swigregister 7847 GeomTransformer_swigregister(GeomTransformer) 7848 7849
7850 -def GetDriverCount(*args):
7851 """GetDriverCount() -> int""" 7852 return _ogr.GetDriverCount(*args)
7853
7854 -def GetOpenDSCount(*args):
7855 """GetOpenDSCount() -> int""" 7856 return _ogr.GetOpenDSCount(*args)
7857
7858 -def SetGenerate_DB2_V72_BYTE_ORDER(*args):
7859 """SetGenerate_DB2_V72_BYTE_ORDER(int bGenerate_DB2_V72_BYTE_ORDER) -> OGRErr""" 7860 return _ogr.SetGenerate_DB2_V72_BYTE_ORDER(*args)
7861
7862 -def RegisterAll(*args):
7863 """RegisterAll()""" 7864 return _ogr.RegisterAll(*args)
7865
7866 -def GeometryTypeToName(*args):
7867 """GeometryTypeToName(OGRwkbGeometryType eType) -> char const *""" 7868 return _ogr.GeometryTypeToName(*args)
7869
7870 -def GetFieldTypeName(*args):
7871 """GetFieldTypeName(OGRFieldType type) -> char const *""" 7872 return _ogr.GetFieldTypeName(*args)
7873
7874 -def GetFieldSubTypeName(*args):
7875 """GetFieldSubTypeName(OGRFieldSubType type) -> char const *""" 7876 return _ogr.GetFieldSubTypeName(*args)
7877
7878 -def GT_Flatten(*args):
7879 """GT_Flatten(OGRwkbGeometryType eType) -> OGRwkbGeometryType""" 7880 return _ogr.GT_Flatten(*args)
7881
7882 -def GT_SetZ(*args):
7883 """GT_SetZ(OGRwkbGeometryType eType) -> OGRwkbGeometryType""" 7884 return _ogr.GT_SetZ(*args)
7885
7886 -def GT_SetM(*args):
7887 """GT_SetM(OGRwkbGeometryType eType) -> OGRwkbGeometryType""" 7888 return _ogr.GT_SetM(*args)
7889
7890 -def GT_SetModifier(*args):
7891 """GT_SetModifier(OGRwkbGeometryType eType, int bSetZ, int bSetM=False) -> OGRwkbGeometryType""" 7892 return _ogr.GT_SetModifier(*args)
7893
7894 -def GT_HasZ(*args):
7895 """GT_HasZ(OGRwkbGeometryType eType) -> int""" 7896 return _ogr.GT_HasZ(*args)
7897
7898 -def GT_HasM(*args):
7899 """GT_HasM(OGRwkbGeometryType eType) -> int""" 7900 return _ogr.GT_HasM(*args)
7901
7902 -def GT_IsSubClassOf(*args):
7903 """GT_IsSubClassOf(OGRwkbGeometryType eType, OGRwkbGeometryType eSuperType) -> int""" 7904 return _ogr.GT_IsSubClassOf(*args)
7905
7906 -def GT_IsCurve(*args):
7907 """GT_IsCurve(OGRwkbGeometryType arg1) -> int""" 7908 return _ogr.GT_IsCurve(*args)
7909
7910 -def GT_IsSurface(*args):
7911 """GT_IsSurface(OGRwkbGeometryType arg1) -> int""" 7912 return _ogr.GT_IsSurface(*args)
7913
7914 -def GT_IsNonLinear(*args):
7915 """GT_IsNonLinear(OGRwkbGeometryType arg1) -> int""" 7916 return _ogr.GT_IsNonLinear(*args)
7917
7918 -def GT_GetCollection(*args):
7919 """GT_GetCollection(OGRwkbGeometryType eType) -> OGRwkbGeometryType""" 7920 return _ogr.GT_GetCollection(*args)
7921
7922 -def GT_GetCurve(*args):
7923 """GT_GetCurve(OGRwkbGeometryType eType) -> OGRwkbGeometryType""" 7924 return _ogr.GT_GetCurve(*args)
7925
7926 -def GT_GetLinear(*args):
7927 """GT_GetLinear(OGRwkbGeometryType eType) -> OGRwkbGeometryType""" 7928 return _ogr.GT_GetLinear(*args)
7929
7930 -def SetNonLinearGeometriesEnabledFlag(*args):
7931 """SetNonLinearGeometriesEnabledFlag(int bFlag)""" 7932 return _ogr.SetNonLinearGeometriesEnabledFlag(*args)
7933
7934 -def GetNonLinearGeometriesEnabledFlag(*args):
7935 """GetNonLinearGeometriesEnabledFlag() -> int""" 7936 return _ogr.GetNonLinearGeometriesEnabledFlag(*args)
7937
7938 -def GetOpenDS(*args):
7939 """GetOpenDS(int ds_number) -> DataSource""" 7940 return _ogr.GetOpenDS(*args)
7941
7942 -def Open(*args, **kwargs):
7943 """Open(char const * utf8_path, int update=0) -> DataSource""" 7944 return _ogr.Open(*args, **kwargs)
7945
7946 -def OpenShared(*args, **kwargs):
7947 """OpenShared(char const * utf8_path, int update=0) -> DataSource""" 7948 return _ogr.OpenShared(*args, **kwargs)
7949
7950 -def GetDriverByName(*args):
7951 """GetDriverByName(char const * name) -> Driver""" 7952 return _ogr.GetDriverByName(*args)
7953
7954 -def GetDriver(*args):
7955 """GetDriver(int driver_number) -> Driver""" 7956 return _ogr.GetDriver(*args)
7957
7958 -def GeneralCmdLineProcessor(*args):
7959 """GeneralCmdLineProcessor(char ** papszArgv, int nOptions=0) -> char **""" 7960 return _ogr.GeneralCmdLineProcessor(*args)
7961
7962 -def TermProgress_nocb(*args, **kwargs):
7963 """TermProgress_nocb(double dfProgress, char const * pszMessage=None, void * pData=None) -> int""" 7964 return _ogr.TermProgress_nocb(*args, **kwargs)
7965 TermProgress = _ogr.TermProgress 7966 # This file is compatible with both classic and new-style classes. 7967