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

# Source Code for Module osgeo.ogr

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