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