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

Source Code for Module osgeo.ogr

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