8144 lines
258 KiB
Python
8144 lines
258 KiB
Python
# This file was automatically generated by SWIG (http://www.swig.org).
|
|
# Version 3.0.12
|
|
#
|
|
# Do not make changes to this file unless you know what you are doing--modify
|
|
# the SWIG interface file instead.
|
|
|
|
from sys import version_info as _swig_python_version_info
|
|
if _swig_python_version_info >= (2, 7, 0):
|
|
def swig_import_helper():
|
|
import importlib
|
|
pkg = __name__.rpartition('.')[0]
|
|
mname = '.'.join((pkg, '_ogr')).lstrip('.')
|
|
try:
|
|
return importlib.import_module(mname)
|
|
except ImportError:
|
|
return importlib.import_module('_ogr')
|
|
_ogr = swig_import_helper()
|
|
del swig_import_helper
|
|
elif _swig_python_version_info >= (2, 6, 0):
|
|
def swig_import_helper():
|
|
from os.path import dirname
|
|
import imp
|
|
fp = None
|
|
try:
|
|
fp, pathname, description = imp.find_module('_ogr', [dirname(__file__)])
|
|
except ImportError:
|
|
import _ogr
|
|
return _ogr
|
|
try:
|
|
_mod = imp.load_module('_ogr', fp, pathname, description)
|
|
finally:
|
|
if fp is not None:
|
|
fp.close()
|
|
return _mod
|
|
_ogr = swig_import_helper()
|
|
del swig_import_helper
|
|
else:
|
|
import _ogr
|
|
del _swig_python_version_info
|
|
|
|
try:
|
|
_swig_property = property
|
|
except NameError:
|
|
pass # Python < 2.2 doesn't have 'property'.
|
|
|
|
try:
|
|
import builtins as __builtin__
|
|
except ImportError:
|
|
import __builtin__
|
|
|
|
def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
|
|
if (name == "thisown"):
|
|
return self.this.own(value)
|
|
if (name == "this"):
|
|
if type(value).__name__ == 'SwigPyObject':
|
|
self.__dict__[name] = value
|
|
return
|
|
method = class_type.__swig_setmethods__.get(name, None)
|
|
if method:
|
|
return method(self, value)
|
|
if (not static):
|
|
if _newclass:
|
|
object.__setattr__(self, name, value)
|
|
else:
|
|
self.__dict__[name] = value
|
|
else:
|
|
raise AttributeError("You cannot add attributes to %s" % self)
|
|
|
|
|
|
def _swig_setattr(self, class_type, name, value):
|
|
return _swig_setattr_nondynamic(self, class_type, name, value, 0)
|
|
|
|
|
|
def _swig_getattr(self, class_type, name):
|
|
if (name == "thisown"):
|
|
return self.this.own()
|
|
method = class_type.__swig_getmethods__.get(name, None)
|
|
if method:
|
|
return method(self)
|
|
raise AttributeError("'%s' object has no attribute '%s'" % (class_type.__name__, name))
|
|
|
|
|
|
def _swig_repr(self):
|
|
try:
|
|
strthis = "proxy of " + self.this.__repr__()
|
|
except __builtin__.Exception:
|
|
strthis = ""
|
|
return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
|
|
|
|
try:
|
|
_object = object
|
|
_newclass = 1
|
|
except __builtin__.Exception:
|
|
class _object:
|
|
pass
|
|
_newclass = 0
|
|
|
|
wkb25DBit = _ogr.wkb25DBit
|
|
wkb25Bit = _ogr.wkb25Bit
|
|
wkbUnknown = _ogr.wkbUnknown
|
|
wkbPoint = _ogr.wkbPoint
|
|
wkbLineString = _ogr.wkbLineString
|
|
wkbPolygon = _ogr.wkbPolygon
|
|
wkbMultiPoint = _ogr.wkbMultiPoint
|
|
wkbMultiLineString = _ogr.wkbMultiLineString
|
|
wkbMultiPolygon = _ogr.wkbMultiPolygon
|
|
wkbGeometryCollection = _ogr.wkbGeometryCollection
|
|
wkbCircularString = _ogr.wkbCircularString
|
|
wkbCompoundCurve = _ogr.wkbCompoundCurve
|
|
wkbCurvePolygon = _ogr.wkbCurvePolygon
|
|
wkbMultiCurve = _ogr.wkbMultiCurve
|
|
wkbMultiSurface = _ogr.wkbMultiSurface
|
|
wkbCurve = _ogr.wkbCurve
|
|
wkbSurface = _ogr.wkbSurface
|
|
wkbPolyhedralSurface = _ogr.wkbPolyhedralSurface
|
|
wkbTIN = _ogr.wkbTIN
|
|
wkbTriangle = _ogr.wkbTriangle
|
|
wkbNone = _ogr.wkbNone
|
|
wkbLinearRing = _ogr.wkbLinearRing
|
|
wkbCircularStringZ = _ogr.wkbCircularStringZ
|
|
wkbCompoundCurveZ = _ogr.wkbCompoundCurveZ
|
|
wkbCurvePolygonZ = _ogr.wkbCurvePolygonZ
|
|
wkbMultiCurveZ = _ogr.wkbMultiCurveZ
|
|
wkbMultiSurfaceZ = _ogr.wkbMultiSurfaceZ
|
|
wkbCurveZ = _ogr.wkbCurveZ
|
|
wkbSurfaceZ = _ogr.wkbSurfaceZ
|
|
wkbPolyhedralSurfaceZ = _ogr.wkbPolyhedralSurfaceZ
|
|
wkbTINZ = _ogr.wkbTINZ
|
|
wkbTriangleZ = _ogr.wkbTriangleZ
|
|
wkbPointM = _ogr.wkbPointM
|
|
wkbLineStringM = _ogr.wkbLineStringM
|
|
wkbPolygonM = _ogr.wkbPolygonM
|
|
wkbMultiPointM = _ogr.wkbMultiPointM
|
|
wkbMultiLineStringM = _ogr.wkbMultiLineStringM
|
|
wkbMultiPolygonM = _ogr.wkbMultiPolygonM
|
|
wkbGeometryCollectionM = _ogr.wkbGeometryCollectionM
|
|
wkbCircularStringM = _ogr.wkbCircularStringM
|
|
wkbCompoundCurveM = _ogr.wkbCompoundCurveM
|
|
wkbCurvePolygonM = _ogr.wkbCurvePolygonM
|
|
wkbMultiCurveM = _ogr.wkbMultiCurveM
|
|
wkbMultiSurfaceM = _ogr.wkbMultiSurfaceM
|
|
wkbCurveM = _ogr.wkbCurveM
|
|
wkbSurfaceM = _ogr.wkbSurfaceM
|
|
wkbPolyhedralSurfaceM = _ogr.wkbPolyhedralSurfaceM
|
|
wkbTINM = _ogr.wkbTINM
|
|
wkbTriangleM = _ogr.wkbTriangleM
|
|
wkbPointZM = _ogr.wkbPointZM
|
|
wkbLineStringZM = _ogr.wkbLineStringZM
|
|
wkbPolygonZM = _ogr.wkbPolygonZM
|
|
wkbMultiPointZM = _ogr.wkbMultiPointZM
|
|
wkbMultiLineStringZM = _ogr.wkbMultiLineStringZM
|
|
wkbMultiPolygonZM = _ogr.wkbMultiPolygonZM
|
|
wkbGeometryCollectionZM = _ogr.wkbGeometryCollectionZM
|
|
wkbCircularStringZM = _ogr.wkbCircularStringZM
|
|
wkbCompoundCurveZM = _ogr.wkbCompoundCurveZM
|
|
wkbCurvePolygonZM = _ogr.wkbCurvePolygonZM
|
|
wkbMultiCurveZM = _ogr.wkbMultiCurveZM
|
|
wkbMultiSurfaceZM = _ogr.wkbMultiSurfaceZM
|
|
wkbCurveZM = _ogr.wkbCurveZM
|
|
wkbSurfaceZM = _ogr.wkbSurfaceZM
|
|
wkbPolyhedralSurfaceZM = _ogr.wkbPolyhedralSurfaceZM
|
|
wkbTINZM = _ogr.wkbTINZM
|
|
wkbTriangleZM = _ogr.wkbTriangleZM
|
|
wkbPoint25D = _ogr.wkbPoint25D
|
|
wkbLineString25D = _ogr.wkbLineString25D
|
|
wkbPolygon25D = _ogr.wkbPolygon25D
|
|
wkbMultiPoint25D = _ogr.wkbMultiPoint25D
|
|
wkbMultiLineString25D = _ogr.wkbMultiLineString25D
|
|
wkbMultiPolygon25D = _ogr.wkbMultiPolygon25D
|
|
wkbGeometryCollection25D = _ogr.wkbGeometryCollection25D
|
|
OFTInteger = _ogr.OFTInteger
|
|
OFTIntegerList = _ogr.OFTIntegerList
|
|
OFTReal = _ogr.OFTReal
|
|
OFTRealList = _ogr.OFTRealList
|
|
OFTString = _ogr.OFTString
|
|
OFTStringList = _ogr.OFTStringList
|
|
OFTWideString = _ogr.OFTWideString
|
|
OFTWideStringList = _ogr.OFTWideStringList
|
|
OFTBinary = _ogr.OFTBinary
|
|
OFTDate = _ogr.OFTDate
|
|
OFTTime = _ogr.OFTTime
|
|
OFTDateTime = _ogr.OFTDateTime
|
|
OFTInteger64 = _ogr.OFTInteger64
|
|
OFTInteger64List = _ogr.OFTInteger64List
|
|
OFSTNone = _ogr.OFSTNone
|
|
OFSTBoolean = _ogr.OFSTBoolean
|
|
OFSTInt16 = _ogr.OFSTInt16
|
|
OFSTFloat32 = _ogr.OFSTFloat32
|
|
OFSTJSON = _ogr.OFSTJSON
|
|
OFSTUUID = _ogr.OFSTUUID
|
|
OJUndefined = _ogr.OJUndefined
|
|
OJLeft = _ogr.OJLeft
|
|
OJRight = _ogr.OJRight
|
|
OFDT_CODED = _ogr.OFDT_CODED
|
|
OFDT_RANGE = _ogr.OFDT_RANGE
|
|
OFDT_GLOB = _ogr.OFDT_GLOB
|
|
OFDSP_DEFAULT_VALUE = _ogr.OFDSP_DEFAULT_VALUE
|
|
OFDSP_DUPLICATE = _ogr.OFDSP_DUPLICATE
|
|
OFDSP_GEOMETRY_RATIO = _ogr.OFDSP_GEOMETRY_RATIO
|
|
OFDMP_DEFAULT_VALUE = _ogr.OFDMP_DEFAULT_VALUE
|
|
OFDMP_SUM = _ogr.OFDMP_SUM
|
|
OFDMP_GEOMETRY_WEIGHTED = _ogr.OFDMP_GEOMETRY_WEIGHTED
|
|
wkbXDR = _ogr.wkbXDR
|
|
wkbNDR = _ogr.wkbNDR
|
|
NullFID = _ogr.NullFID
|
|
ALTER_NAME_FLAG = _ogr.ALTER_NAME_FLAG
|
|
ALTER_TYPE_FLAG = _ogr.ALTER_TYPE_FLAG
|
|
ALTER_WIDTH_PRECISION_FLAG = _ogr.ALTER_WIDTH_PRECISION_FLAG
|
|
ALTER_NULLABLE_FLAG = _ogr.ALTER_NULLABLE_FLAG
|
|
ALTER__FLAG = _ogr.ALTER__FLAG
|
|
ALTER_DEFAULT_FLAG = _ogr.ALTER_DEFAULT_FLAG
|
|
ALTER_UNIQUE_FLAG = _ogr.ALTER_UNIQUE_FLAG
|
|
ALTER_DOMAIN_FLAG = _ogr.ALTER_DOMAIN_FLAG
|
|
ALTER_ALL_FLAG = _ogr.ALTER_ALL_FLAG
|
|
F_VAL_NULL = _ogr.F_VAL_NULL
|
|
F_VAL_GEOM_TYPE = _ogr.F_VAL_GEOM_TYPE
|
|
F_VAL_WIDTH = _ogr.F_VAL_WIDTH
|
|
F_VAL_ALLOW_NULL_WHEN_DEFAULT = _ogr.F_VAL_ALLOW_NULL_WHEN_DEFAULT
|
|
F_VAL_ALL = _ogr.F_VAL_ALL
|
|
OLCRandomRead = _ogr.OLCRandomRead
|
|
OLCSequentialWrite = _ogr.OLCSequentialWrite
|
|
OLCRandomWrite = _ogr.OLCRandomWrite
|
|
OLCFastSpatialFilter = _ogr.OLCFastSpatialFilter
|
|
OLCFastFeatureCount = _ogr.OLCFastFeatureCount
|
|
OLCFastGetExtent = _ogr.OLCFastGetExtent
|
|
OLCCreateField = _ogr.OLCCreateField
|
|
OLCDeleteField = _ogr.OLCDeleteField
|
|
OLCReorderFields = _ogr.OLCReorderFields
|
|
OLCAlterFieldDefn = _ogr.OLCAlterFieldDefn
|
|
OLCTransactions = _ogr.OLCTransactions
|
|
OLCDeleteFeature = _ogr.OLCDeleteFeature
|
|
OLCFastSetNextByIndex = _ogr.OLCFastSetNextByIndex
|
|
OLCStringsAsUTF8 = _ogr.OLCStringsAsUTF8
|
|
OLCIgnoreFields = _ogr.OLCIgnoreFields
|
|
OLCCreateGeomField = _ogr.OLCCreateGeomField
|
|
OLCCurveGeometries = _ogr.OLCCurveGeometries
|
|
OLCMeasuredGeometries = _ogr.OLCMeasuredGeometries
|
|
ODsCCreateLayer = _ogr.ODsCCreateLayer
|
|
ODsCDeleteLayer = _ogr.ODsCDeleteLayer
|
|
ODsCCreateGeomFieldAfterCreateLayer = _ogr.ODsCCreateGeomFieldAfterCreateLayer
|
|
ODsCCurveGeometries = _ogr.ODsCCurveGeometries
|
|
ODsCTransactions = _ogr.ODsCTransactions
|
|
ODsCEmulatedTransactions = _ogr.ODsCEmulatedTransactions
|
|
ODsCMeasuredGeometries = _ogr.ODsCMeasuredGeometries
|
|
ODsCRandomLayerRead = _ogr.ODsCRandomLayerRead
|
|
ODsCRandomLayerWrite = _ogr.ODsCRandomLayerWrite
|
|
ODsCAddFieldDomain = _ogr.ODsCAddFieldDomain
|
|
ODrCCreateDataSource = _ogr.ODrCCreateDataSource
|
|
ODrCDeleteDataSource = _ogr.ODrCDeleteDataSource
|
|
OLMD_FID64 = _ogr.OLMD_FID64
|
|
OGRERR_NONE = _ogr.OGRERR_NONE
|
|
OGRERR_NOT_ENOUGH_DATA = _ogr.OGRERR_NOT_ENOUGH_DATA
|
|
OGRERR_NOT_ENOUGH_MEMORY = _ogr.OGRERR_NOT_ENOUGH_MEMORY
|
|
OGRERR_UNSUPPORTED_GEOMETRY_TYPE = _ogr.OGRERR_UNSUPPORTED_GEOMETRY_TYPE
|
|
OGRERR_UNSUPPORTED_OPERATION = _ogr.OGRERR_UNSUPPORTED_OPERATION
|
|
OGRERR_CORRUPT_DATA = _ogr.OGRERR_CORRUPT_DATA
|
|
OGRERR_FAILURE = _ogr.OGRERR_FAILURE
|
|
OGRERR_UNSUPPORTED_SRS = _ogr.OGRERR_UNSUPPORTED_SRS
|
|
OGRERR_INVALID_HANDLE = _ogr.OGRERR_INVALID_HANDLE
|
|
OGRERR_NON_EXISTING_FEATURE = _ogr.OGRERR_NON_EXISTING_FEATURE
|
|
|
|
def GetUseExceptions(*args):
|
|
"""GetUseExceptions() -> int"""
|
|
return _ogr.GetUseExceptions(*args)
|
|
|
|
def UseExceptions(*args):
|
|
"""UseExceptions()"""
|
|
return _ogr.UseExceptions(*args)
|
|
|
|
def DontUseExceptions(*args):
|
|
"""DontUseExceptions()"""
|
|
return _ogr.DontUseExceptions(*args)
|
|
from sys import version_info as _swig_python_version_info
|
|
if _swig_python_version_info >= (2, 7, 0):
|
|
from . import osr
|
|
else:
|
|
import osr
|
|
del _swig_python_version_info
|
|
class MajorObject(_object):
|
|
"""Proxy of C++ GDALMajorObjectShadow class."""
|
|
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, MajorObject, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, MajorObject, name)
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined")
|
|
__repr__ = _swig_repr
|
|
|
|
def GetDescription(self, *args):
|
|
"""GetDescription(MajorObject self) -> char const *"""
|
|
return _ogr.MajorObject_GetDescription(self, *args)
|
|
|
|
|
|
def SetDescription(self, *args):
|
|
"""SetDescription(MajorObject self, char const * pszNewDesc)"""
|
|
return _ogr.MajorObject_SetDescription(self, *args)
|
|
|
|
|
|
def GetMetadataDomainList(self, *args):
|
|
"""GetMetadataDomainList(MajorObject self) -> char **"""
|
|
return _ogr.MajorObject_GetMetadataDomainList(self, *args)
|
|
|
|
|
|
def GetMetadata_Dict(self, *args):
|
|
"""GetMetadata_Dict(MajorObject self, char const * pszDomain) -> char **"""
|
|
return _ogr.MajorObject_GetMetadata_Dict(self, *args)
|
|
|
|
|
|
def GetMetadata_List(self, *args):
|
|
"""GetMetadata_List(MajorObject self, char const * pszDomain) -> char **"""
|
|
return _ogr.MajorObject_GetMetadata_List(self, *args)
|
|
|
|
|
|
def SetMetadata(self, *args):
|
|
"""
|
|
SetMetadata(MajorObject self, char ** papszMetadata, char const * pszDomain) -> CPLErr
|
|
SetMetadata(MajorObject self, char * pszMetadataString, char const * pszDomain) -> CPLErr
|
|
"""
|
|
return _ogr.MajorObject_SetMetadata(self, *args)
|
|
|
|
|
|
def GetMetadataItem(self, *args):
|
|
"""GetMetadataItem(MajorObject self, char const * pszName, char const * pszDomain) -> char const *"""
|
|
return _ogr.MajorObject_GetMetadataItem(self, *args)
|
|
|
|
|
|
def SetMetadataItem(self, *args):
|
|
"""SetMetadataItem(MajorObject self, char const * pszName, char const * pszValue, char const * pszDomain) -> CPLErr"""
|
|
return _ogr.MajorObject_SetMetadataItem(self, *args)
|
|
|
|
|
|
def GetMetadata(self, domain=''):
|
|
if domain[:4] == 'xml:':
|
|
return self.GetMetadata_List(domain)
|
|
return self.GetMetadata_Dict(domain)
|
|
|
|
MajorObject_swigregister = _ogr.MajorObject_swigregister
|
|
MajorObject_swigregister(MajorObject)
|
|
|
|
class StyleTable(_object):
|
|
"""Proxy of C++ OGRStyleTableShadow class."""
|
|
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, StyleTable, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, StyleTable, name)
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, *args):
|
|
"""__init__(OGRStyleTableShadow self) -> StyleTable"""
|
|
this = _ogr.new_StyleTable(*args)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
__swig_destroy__ = _ogr.delete_StyleTable
|
|
__del__ = lambda self: None
|
|
|
|
def AddStyle(self, *args):
|
|
"""AddStyle(StyleTable self, char const * pszName, char const * pszStyleString) -> int"""
|
|
return _ogr.StyleTable_AddStyle(self, *args)
|
|
|
|
|
|
def LoadStyleTable(self, *args):
|
|
"""LoadStyleTable(StyleTable self, char const * utf8_path) -> int"""
|
|
return _ogr.StyleTable_LoadStyleTable(self, *args)
|
|
|
|
|
|
def SaveStyleTable(self, *args):
|
|
"""SaveStyleTable(StyleTable self, char const * utf8_path) -> int"""
|
|
return _ogr.StyleTable_SaveStyleTable(self, *args)
|
|
|
|
|
|
def Find(self, *args):
|
|
"""Find(StyleTable self, char const * pszName) -> char const *"""
|
|
return _ogr.StyleTable_Find(self, *args)
|
|
|
|
|
|
def ResetStyleStringReading(self, *args):
|
|
"""ResetStyleStringReading(StyleTable self)"""
|
|
return _ogr.StyleTable_ResetStyleStringReading(self, *args)
|
|
|
|
|
|
def GetNextStyle(self, *args):
|
|
"""GetNextStyle(StyleTable self) -> char const *"""
|
|
return _ogr.StyleTable_GetNextStyle(self, *args)
|
|
|
|
|
|
def GetLastStyleName(self, *args):
|
|
"""GetLastStyleName(StyleTable self) -> char const *"""
|
|
return _ogr.StyleTable_GetLastStyleName(self, *args)
|
|
|
|
StyleTable_swigregister = _ogr.StyleTable_swigregister
|
|
StyleTable_swigregister(StyleTable)
|
|
|
|
class Driver(MajorObject):
|
|
"""Proxy of C++ OGRDriverShadow class."""
|
|
|
|
__swig_setmethods__ = {}
|
|
for _s in [MajorObject]:
|
|
__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, Driver, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [MajorObject]:
|
|
__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, Driver, name)
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined")
|
|
__repr__ = _swig_repr
|
|
__swig_getmethods__["name"] = _ogr.Driver_name_get
|
|
if _newclass:
|
|
name = _swig_property(_ogr.Driver_name_get)
|
|
|
|
def CreateDataSource(self, *args, **kwargs):
|
|
"""CreateDataSource(Driver self, char const * utf8_path, char ** options=None) -> DataSource"""
|
|
return _ogr.Driver_CreateDataSource(self, *args, **kwargs)
|
|
|
|
|
|
def CopyDataSource(self, *args, **kwargs):
|
|
"""CopyDataSource(Driver self, DataSource copy_ds, char const * utf8_path, char ** options=None) -> DataSource"""
|
|
return _ogr.Driver_CopyDataSource(self, *args, **kwargs)
|
|
|
|
|
|
def Open(self, *args, **kwargs):
|
|
"""Open(Driver self, char const * utf8_path, int update=0) -> DataSource"""
|
|
return _ogr.Driver_Open(self, *args, **kwargs)
|
|
|
|
|
|
def DeleteDataSource(self, *args):
|
|
"""DeleteDataSource(Driver self, char const * utf8_path) -> int"""
|
|
return _ogr.Driver_DeleteDataSource(self, *args)
|
|
|
|
|
|
def TestCapability(self, *args):
|
|
"""TestCapability(Driver self, char const * cap) -> bool"""
|
|
return _ogr.Driver_TestCapability(self, *args)
|
|
|
|
|
|
def GetName(self, *args):
|
|
"""GetName(Driver self) -> char const *"""
|
|
return _ogr.Driver_GetName(self, *args)
|
|
|
|
|
|
def Register(self, *args):
|
|
"""Register(Driver self)"""
|
|
return _ogr.Driver_Register(self, *args)
|
|
|
|
|
|
def Deregister(self, *args):
|
|
"""Deregister(Driver self)"""
|
|
return _ogr.Driver_Deregister(self, *args)
|
|
|
|
Driver_swigregister = _ogr.Driver_swigregister
|
|
Driver_swigregister(Driver)
|
|
|
|
class DataSource(MajorObject):
|
|
"""Proxy of C++ OGRDataSourceShadow class."""
|
|
|
|
__swig_setmethods__ = {}
|
|
for _s in [MajorObject]:
|
|
__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, DataSource, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [MajorObject]:
|
|
__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, DataSource, name)
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined")
|
|
__repr__ = _swig_repr
|
|
__swig_getmethods__["name"] = _ogr.DataSource_name_get
|
|
if _newclass:
|
|
name = _swig_property(_ogr.DataSource_name_get)
|
|
__swig_destroy__ = _ogr.delete_DataSource
|
|
__del__ = lambda self: None
|
|
|
|
def GetRefCount(self, *args):
|
|
"""
|
|
GetRefCount(DataSource self) -> int
|
|
|
|
int
|
|
OGR_DS_GetRefCount(OGRDataSourceH hDataSource)
|
|
"""
|
|
return _ogr.DataSource_GetRefCount(self, *args)
|
|
|
|
|
|
def GetSummaryRefCount(self, *args):
|
|
"""
|
|
GetSummaryRefCount(DataSource self) -> int
|
|
|
|
int
|
|
OGR_DS_GetSummaryRefCount(OGRDataSourceH hDataSource)
|
|
"""
|
|
return _ogr.DataSource_GetSummaryRefCount(self, *args)
|
|
|
|
|
|
def GetLayerCount(self, *args):
|
|
"""
|
|
GetLayerCount(DataSource self) -> int
|
|
|
|
int
|
|
OGR_DS_GetLayerCount(OGRDataSourceH hDS)
|
|
|
|
Get the number of layers in this data source.
|
|
|
|
Deprecated Use GDALDatasetGetLayerCount() in GDAL 2.0
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hDS: handle to the data source from which to get the number of
|
|
layers.
|
|
|
|
layer count.
|
|
"""
|
|
return _ogr.DataSource_GetLayerCount(self, *args)
|
|
|
|
|
|
def GetDriver(self, *args):
|
|
"""
|
|
GetDriver(DataSource self) -> Driver
|
|
|
|
OGRSFDriverH
|
|
OGR_DS_GetDriver(OGRDataSourceH hDS)
|
|
|
|
Returns the driver that the dataset was opened with.
|
|
|
|
NOTE: Starting with GDAL 2.0, it is NOT safe to cast the returned
|
|
handle to OGRSFDriver*. If a C++ object is needed, the handle should
|
|
be cast to GDALDriver*.
|
|
|
|
Deprecated Use GDALGetDatasetDriver() in GDAL 2.0
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hDS: handle to the datasource
|
|
|
|
NULL if driver info is not available, or pointer to a driver owned by
|
|
the OGRSFDriverManager.
|
|
"""
|
|
return _ogr.DataSource_GetDriver(self, *args)
|
|
|
|
|
|
def GetName(self, *args):
|
|
"""
|
|
GetName(DataSource self) -> char const *
|
|
|
|
const char*
|
|
OGR_DS_GetName(OGRDataSourceH hDS)
|
|
|
|
Returns the name of the data source.
|
|
|
|
This string should be sufficient to open the data source if passed to
|
|
the same OGRSFDriver that this data source was opened with, but it
|
|
need not be exactly the same string that was used to open the data
|
|
source. Normally this is a filename.
|
|
|
|
Deprecated Use GDALGetDescription() in GDAL 2.0
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hDS: handle to the data source to get the name from.
|
|
|
|
pointer to an internal name string which should not be modified or
|
|
freed by the caller.
|
|
"""
|
|
return _ogr.DataSource_GetName(self, *args)
|
|
|
|
|
|
def DeleteLayer(self, *args):
|
|
"""
|
|
DeleteLayer(DataSource self, int index) -> OGRErr
|
|
|
|
OGRErr
|
|
OGR_DS_DeleteLayer(OGRDataSourceH hDS, int iLayer)
|
|
|
|
Delete the indicated layer from the datasource.
|
|
|
|
If this method is supported the ODsCDeleteLayer capability will test
|
|
TRUE on the OGRDataSource.
|
|
|
|
Deprecated Use GDALDatasetDeleteLayer() in GDAL 2.0
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hDS: handle to the datasource
|
|
|
|
iLayer: the index of the layer to delete.
|
|
|
|
OGRERR_NONE on success, or OGRERR_UNSUPPORTED_OPERATION if deleting
|
|
layers is not supported for this datasource.
|
|
"""
|
|
return _ogr.DataSource_DeleteLayer(self, *args)
|
|
|
|
|
|
def SyncToDisk(self, *args):
|
|
"""
|
|
SyncToDisk(DataSource self) -> OGRErr
|
|
|
|
OGRErr
|
|
OGR_DS_SyncToDisk(OGRDataSourceH hDS)
|
|
|
|
Flush pending changes to disk.
|
|
|
|
See GDALDataset::FlushCache()
|
|
"""
|
|
return _ogr.DataSource_SyncToDisk(self, *args)
|
|
|
|
|
|
def FlushCache(self, *args):
|
|
"""FlushCache(DataSource self)"""
|
|
return _ogr.DataSource_FlushCache(self, *args)
|
|
|
|
|
|
def CreateLayer(self, *args, **kwargs):
|
|
"""
|
|
CreateLayer(DataSource self, char const * name, SpatialReference srs=None, OGRwkbGeometryType geom_type, char ** options=None) -> Layer
|
|
|
|
OGRLayerH
|
|
OGR_DS_CreateLayer(OGRDataSourceH hDS, const char *pszName,
|
|
OGRSpatialReferenceH hSpatialRef, OGRwkbGeometryType eType, char
|
|
**papszOptions)
|
|
|
|
This function attempts to create a new layer on the data source with
|
|
the indicated name, coordinate system, geometry type.
|
|
|
|
The papszOptions argument can be used to control driver specific
|
|
creation options. These options are normally documented in the format
|
|
specific documentation.
|
|
|
|
Deprecated Use GDALDatasetCreateLayer() in GDAL 2.0
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hDS: The dataset handle.
|
|
|
|
pszName: the name for the new layer. This should ideally not match
|
|
any existing layer on the datasource.
|
|
|
|
hSpatialRef: handle to the coordinate system to use for the new
|
|
layer, or NULL if no coordinate system is available. The driver might
|
|
only increase the reference counter of the object to take ownership,
|
|
and not make a full copy, so do not use OSRDestroySpatialReference(),
|
|
but OSRRelease() instead when you are done with the object.
|
|
|
|
eType: the geometry type for the layer. Use wkbUnknown if there are
|
|
no constraints on the types geometry to be written.
|
|
|
|
papszOptions: a StringList of name=value options. Options are driver
|
|
specific, and driver information can be found at the following
|
|
url:http://www.gdal.org/ogr_formats.html
|
|
|
|
NULL is returned on failure, or a new OGRLayer handle on success.
|
|
Example:
|
|
"""
|
|
return _ogr.DataSource_CreateLayer(self, *args, **kwargs)
|
|
|
|
|
|
def CopyLayer(self, *args, **kwargs):
|
|
"""
|
|
CopyLayer(DataSource self, Layer src_layer, char const * new_name, char ** options=None) -> Layer
|
|
|
|
OGRLayerH
|
|
OGR_DS_CopyLayer(OGRDataSourceH hDS, OGRLayerH hSrcLayer, const char
|
|
*pszNewName, char **papszOptions)
|
|
|
|
Duplicate an existing layer.
|
|
|
|
This function creates a new layer, duplicate the field definitions of
|
|
the source layer and then duplicate each features of the source layer.
|
|
The papszOptions argument can be used to control driver specific
|
|
creation options. These options are normally documented in the format
|
|
specific documentation. The source layer may come from another
|
|
dataset.
|
|
|
|
Deprecated Use GDALDatasetCopyLayer() in GDAL 2.0
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hDS: handle to the data source where to create the new layer
|
|
|
|
hSrcLayer: handle to the source layer.
|
|
|
|
pszNewName: the name of the layer to create.
|
|
|
|
papszOptions: a StringList of name=value options. Options are driver
|
|
specific.
|
|
|
|
a handle to the layer, or NULL if an error occurs.
|
|
"""
|
|
return _ogr.DataSource_CopyLayer(self, *args, **kwargs)
|
|
|
|
|
|
def GetLayerByIndex(self, *args):
|
|
"""GetLayerByIndex(DataSource self, int index=0) -> Layer"""
|
|
return _ogr.DataSource_GetLayerByIndex(self, *args)
|
|
|
|
|
|
def GetLayerByName(self, *args):
|
|
"""
|
|
GetLayerByName(DataSource self, char const * layer_name) -> Layer
|
|
|
|
OGRLayerH
|
|
OGR_DS_GetLayerByName(OGRDataSourceH hDS, const char *pszName)
|
|
|
|
Fetch a layer by name.
|
|
|
|
The returned layer remains owned by the OGRDataSource and should not
|
|
be deleted by the application.
|
|
|
|
Deprecated Use GDALDatasetGetLayerByName() in GDAL 2.0
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hDS: handle to the data source from which to get the layer.
|
|
|
|
pszLayerName: Layer the layer name of the layer to fetch.
|
|
|
|
a handle to the layer, or NULL if the layer is not found or an error
|
|
occurs.
|
|
"""
|
|
return _ogr.DataSource_GetLayerByName(self, *args)
|
|
|
|
|
|
def TestCapability(self, *args):
|
|
"""
|
|
TestCapability(DataSource self, char const * cap) -> bool
|
|
|
|
int
|
|
OGR_DS_TestCapability(OGRDataSourceH hDS, const char *pszCap)
|
|
|
|
Test if capability is available.
|
|
|
|
One of the following data source capability names can be passed into
|
|
this function, and a TRUE or FALSE value will be returned indicating
|
|
whether or not the capability is available for this object.
|
|
|
|
ODsCCreateLayer: True if this datasource can create new layers.
|
|
|
|
ODsCDeleteLayer: True if this datasource can delete existing layers.
|
|
|
|
ODsCCreateGeomFieldAfterCreateLayer: True if the layers of this
|
|
datasource support CreateGeomField() just after layer creation.
|
|
|
|
ODsCCurveGeometries: True if this datasource supports writing curve
|
|
geometries. (GDAL 2.0). In that case, OLCCurveGeometries must also be
|
|
declared in layers of that dataset.
|
|
|
|
The #define macro forms of the capability names should be used in
|
|
preference to the strings themselves to avoid misspelling.
|
|
|
|
Deprecated Use GDALDatasetTestCapability() in GDAL 2.0
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hDS: handle to the data source against which to test the capability.
|
|
|
|
pszCapability: the capability to test.
|
|
|
|
TRUE if capability available otherwise FALSE.
|
|
"""
|
|
return _ogr.DataSource_TestCapability(self, *args)
|
|
|
|
|
|
def ExecuteSQL(self, *args, **kwargs):
|
|
"""
|
|
ExecuteSQL(DataSource self, char const * statement, Geometry spatialFilter=None, char const * dialect) -> Layer
|
|
|
|
OGRLayerH
|
|
OGR_DS_ExecuteSQL(OGRDataSourceH hDS, const char *pszStatement,
|
|
OGRGeometryH hSpatialFilter, const char *pszDialect)
|
|
|
|
Execute an SQL statement against the data store.
|
|
|
|
The result of an SQL query is either NULL for statements that are in
|
|
error, or that have no results set, or an OGRLayer handle representing
|
|
a results set from the query. Note that this OGRLayer is in addition
|
|
to the layers in the data store and must be destroyed with
|
|
OGR_DS_ReleaseResultSet() before the data source is closed
|
|
(destroyed).
|
|
|
|
For more information on the SQL dialect supported internally by OGR
|
|
review theOGR SQL document. Some drivers (i.e. Oracle and PostGIS)
|
|
pass the SQL directly through to the underlying RDBMS.
|
|
|
|
Starting with OGR 1.10, theSQLITE dialect can also be used.
|
|
|
|
Deprecated Use GDALDatasetExecuteSQL() in GDAL 2.0
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hDS: handle to the data source on which the SQL query is executed.
|
|
|
|
pszSQLCommand: the SQL statement to execute.
|
|
|
|
hSpatialFilter: handle to a geometry which represents a spatial
|
|
filter. Can be NULL.
|
|
|
|
pszDialect: allows control of the statement dialect. If set to NULL,
|
|
the OGR SQL engine will be used, except for RDBMS drivers that will
|
|
use their dedicated SQL engine, unless OGRSQL is explicitly passed as
|
|
the dialect. Starting with OGR 1.10, the SQLITE dialect can also be
|
|
used.
|
|
|
|
a handle to a OGRLayer containing the results of the query.
|
|
Deallocate with OGR_DS_ReleaseResultSet().
|
|
"""
|
|
return _ogr.DataSource_ExecuteSQL(self, *args, **kwargs)
|
|
|
|
|
|
def AbortSQL(self, *args):
|
|
"""AbortSQL(DataSource self) -> OGRErr"""
|
|
return _ogr.DataSource_AbortSQL(self, *args)
|
|
|
|
|
|
def ReleaseResultSet(self, *args):
|
|
"""
|
|
ReleaseResultSet(DataSource self, Layer layer)
|
|
|
|
void
|
|
OGR_DS_ReleaseResultSet(OGRDataSourceH hDS, OGRLayerH hLayer)
|
|
|
|
Release results of OGR_DS_ExecuteSQL().
|
|
|
|
This function should only be used to deallocate OGRLayers resulting
|
|
from an OGR_DS_ExecuteSQL() call on the same OGRDataSource. Failure to
|
|
deallocate a results set before destroying the OGRDataSource may cause
|
|
errors.
|
|
|
|
Deprecated Use GDALDatasetReleaseResultSet() in GDAL 2.0
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hDS: a handle to the data source on which was executed an SQL query.
|
|
|
|
hLayer: handle to the result of a previous OGR_DS_ExecuteSQL() call.
|
|
|
|
"""
|
|
return _ogr.DataSource_ReleaseResultSet(self, *args)
|
|
|
|
|
|
def GetStyleTable(self, *args):
|
|
"""
|
|
GetStyleTable(DataSource self) -> StyleTable
|
|
|
|
OGRStyleTableH
|
|
OGR_DS_GetStyleTable(OGRDataSourceH hDS)
|
|
|
|
Get style table.
|
|
"""
|
|
return _ogr.DataSource_GetStyleTable(self, *args)
|
|
|
|
|
|
def SetStyleTable(self, *args):
|
|
"""
|
|
SetStyleTable(DataSource self, StyleTable table)
|
|
|
|
void
|
|
OGR_DS_SetStyleTable(OGRDataSourceH hDS, OGRStyleTableH hStyleTable)
|
|
|
|
Set style table.
|
|
"""
|
|
return _ogr.DataSource_SetStyleTable(self, *args)
|
|
|
|
|
|
def StartTransaction(self, *args, **kwargs):
|
|
"""StartTransaction(DataSource self, int force=False) -> OGRErr"""
|
|
return _ogr.DataSource_StartTransaction(self, *args, **kwargs)
|
|
|
|
|
|
def CommitTransaction(self, *args):
|
|
"""CommitTransaction(DataSource self) -> OGRErr"""
|
|
return _ogr.DataSource_CommitTransaction(self, *args)
|
|
|
|
|
|
def RollbackTransaction(self, *args):
|
|
"""RollbackTransaction(DataSource self) -> OGRErr"""
|
|
return _ogr.DataSource_RollbackTransaction(self, *args)
|
|
|
|
|
|
def Destroy(self):
|
|
"Once called, self has effectively been destroyed. Do not access. For backwards compatibility only"
|
|
_ogr.delete_DataSource(self)
|
|
self.thisown = 0
|
|
|
|
def Release(self):
|
|
"Once called, self has effectively been destroyed. Do not access. For backwards compatibility only"
|
|
_ogr.delete_DataSource(self)
|
|
self.thisown = 0
|
|
|
|
def Reference(self):
|
|
"For backwards compatibility only."
|
|
return self.Reference()
|
|
|
|
def Dereference(self):
|
|
"For backwards compatibility only."
|
|
self.Dereference()
|
|
|
|
def __len__(self):
|
|
"""Returns the number of layers on the datasource"""
|
|
return self.GetLayerCount()
|
|
|
|
def __getitem__(self, value):
|
|
"""Support dictionary, list, and slice -like access to the datasource.
|
|
ds[0] would return the first layer on the datasource.
|
|
ds['aname'] would return the layer named "aname".
|
|
ds[0:4] would return a list of the first four layers."""
|
|
if isinstance(value, slice):
|
|
output = []
|
|
step = value.step if value.step else 1
|
|
for i in range(value.start, value.stop, step):
|
|
lyr = self.GetLayer(i)
|
|
if lyr is None:
|
|
return output
|
|
output.append(lyr)
|
|
return output
|
|
if isinstance(value, int):
|
|
if value > len(self) - 1:
|
|
raise IndexError
|
|
return self.GetLayer(value)
|
|
elif isinstance(value, str):
|
|
return self.GetLayer(value)
|
|
else:
|
|
raise TypeError('Input %s is not of String or Int type' % type(value))
|
|
|
|
def GetLayer(self, iLayer=0):
|
|
"""Return the layer given an index or a name"""
|
|
if isinstance(iLayer, str):
|
|
return self.GetLayerByName(str(iLayer))
|
|
elif isinstance(iLayer, int):
|
|
return self.GetLayerByIndex(iLayer)
|
|
else:
|
|
raise TypeError("Input %s is not of String or Int type" % type(iLayer))
|
|
|
|
def DeleteLayer(self, value):
|
|
"""Deletes the layer given an index or layer name"""
|
|
if isinstance(value, str):
|
|
for i in range(self.GetLayerCount()):
|
|
name = self.GetLayer(i).GetName()
|
|
if name == value:
|
|
return _ogr.DataSource_DeleteLayer(self, i)
|
|
raise ValueError("Layer %s not found to delete" % value)
|
|
elif isinstance(value, int):
|
|
return _ogr.DataSource_DeleteLayer(self, value)
|
|
else:
|
|
raise TypeError("Input %s is not of String or Int type" % type(value))
|
|
|
|
DataSource_swigregister = _ogr.DataSource_swigregister
|
|
DataSource_swigregister(DataSource)
|
|
|
|
class Layer(MajorObject):
|
|
"""Proxy of C++ OGRLayerShadow class."""
|
|
|
|
__swig_setmethods__ = {}
|
|
for _s in [MajorObject]:
|
|
__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, Layer, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [MajorObject]:
|
|
__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, Layer, name)
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined")
|
|
__repr__ = _swig_repr
|
|
|
|
def GetRefCount(self, *args):
|
|
"""
|
|
GetRefCount(Layer self) -> int
|
|
|
|
int OGR_L_GetRefCount(OGRLayerH
|
|
hLayer)
|
|
"""
|
|
return _ogr.Layer_GetRefCount(self, *args)
|
|
|
|
|
|
def SetSpatialFilter(self, *args):
|
|
"""
|
|
SetSpatialFilter(Layer self, Geometry filter)
|
|
SetSpatialFilter(Layer self, int iGeomField, Geometry filter)
|
|
|
|
void
|
|
OGR_L_SetSpatialFilter(OGRLayerH hLayer, OGRGeometryH hGeom)
|
|
|
|
Set a new spatial filter.
|
|
|
|
This function set the geometry to be used as a spatial filter when
|
|
fetching features via the OGR_L_GetNextFeature() function. Only
|
|
features that geometrically intersect the filter geometry will be
|
|
returned.
|
|
|
|
Currently this test is may be inaccurately implemented, but it is
|
|
guaranteed that all features whose envelope (as returned by
|
|
OGR_G_GetEnvelope()) overlaps the envelope of the spatial filter will
|
|
be returned. This can result in more shapes being returned that should
|
|
strictly be the case.
|
|
|
|
Starting with GDAL 2.3, features with null or empty geometries will
|
|
never be considered as matching a spatial filter.
|
|
|
|
This function makes an internal copy of the passed geometry. The
|
|
passed geometry remains the responsibility of the caller, and may be
|
|
safely destroyed.
|
|
|
|
For the time being the passed filter geometry should be in the same
|
|
SRS as the layer (as returned by OGR_L_GetSpatialRef()). In the future
|
|
this may be generalized.
|
|
|
|
This function is the same as the C++ method
|
|
OGRLayer::SetSpatialFilter.
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hLayer: handle to the layer on which to set the spatial filter.
|
|
|
|
hGeom: handle to the geometry to use as a filtering region. NULL may
|
|
be passed indicating that the current spatial filter should be
|
|
cleared, but no new one instituted.
|
|
"""
|
|
return _ogr.Layer_SetSpatialFilter(self, *args)
|
|
|
|
|
|
def SetSpatialFilterRect(self, *args):
|
|
"""
|
|
SetSpatialFilterRect(Layer self, double minx, double miny, double maxx, double maxy)
|
|
SetSpatialFilterRect(Layer self, int iGeomField, double minx, double miny, double maxx, double maxy)
|
|
|
|
void
|
|
OGR_L_SetSpatialFilterRect(OGRLayerH hLayer, double dfMinX, double
|
|
dfMinY, double dfMaxX, double dfMaxY)
|
|
|
|
Set a new rectangular spatial filter.
|
|
|
|
This method set rectangle to be used as a spatial filter when fetching
|
|
features via the OGR_L_GetNextFeature() method. Only features that
|
|
geometrically intersect the given rectangle will be returned.
|
|
|
|
The x/y values should be in the same coordinate system as the layer as
|
|
a whole (as returned by OGRLayer::GetSpatialRef()). Internally this
|
|
method is normally implemented as creating a 5 vertex closed
|
|
rectangular polygon and passing it to OGRLayer::SetSpatialFilter(). It
|
|
exists as a convenience.
|
|
|
|
The only way to clear a spatial filter set with this method is to call
|
|
OGRLayer::SetSpatialFilter(NULL).
|
|
|
|
This method is the same as the C++ method
|
|
OGRLayer::SetSpatialFilterRect().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hLayer: handle to the layer on which to set the spatial filter.
|
|
|
|
dfMinX: the minimum X coordinate for the rectangular region.
|
|
|
|
dfMinY: the minimum Y coordinate for the rectangular region.
|
|
|
|
dfMaxX: the maximum X coordinate for the rectangular region.
|
|
|
|
dfMaxY: the maximum Y coordinate for the rectangular region.
|
|
"""
|
|
return _ogr.Layer_SetSpatialFilterRect(self, *args)
|
|
|
|
|
|
def GetSpatialFilter(self, *args):
|
|
"""
|
|
GetSpatialFilter(Layer self) -> Geometry
|
|
|
|
OGRGeometryH
|
|
OGR_L_GetSpatialFilter(OGRLayerH hLayer)
|
|
|
|
This function returns the current spatial filter for this layer.
|
|
|
|
The returned pointer is to an internally owned object, and should not
|
|
be altered or deleted by the caller.
|
|
|
|
This function is the same as the C++ method
|
|
OGRLayer::GetSpatialFilter().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hLayer: handle to the layer to get the spatial filter from.
|
|
|
|
a handle to the spatial filter geometry.
|
|
"""
|
|
return _ogr.Layer_GetSpatialFilter(self, *args)
|
|
|
|
|
|
def SetAttributeFilter(self, *args):
|
|
"""
|
|
SetAttributeFilter(Layer self, char * filter_string) -> OGRErr
|
|
|
|
OGRErr
|
|
OGR_L_SetAttributeFilter(OGRLayerH hLayer, const char *pszQuery)
|
|
|
|
Set a new attribute query.
|
|
|
|
This function sets the attribute query string to be used when fetching
|
|
features via the OGR_L_GetNextFeature() function. Only features for
|
|
which the query evaluates as true will be returned.
|
|
|
|
The query string should be in the format of an SQL WHERE clause. For
|
|
instance "population > 1000000 and population < 5000000" where
|
|
population is an attribute in the layer. The query format is a
|
|
restricted form of SQL WHERE clause as defined
|
|
"eq_format=restricted_where" about half way through this document:
|
|
|
|
http://ogdi.sourceforge.net/prop/6.2.CapabilitiesMetadata.html
|
|
|
|
Note that installing a query string will generally result in resetting
|
|
the current reading position (ala OGR_L_ResetReading()).
|
|
|
|
This function is the same as the C++ method
|
|
OGRLayer::SetAttributeFilter().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hLayer: handle to the layer on which attribute query will be
|
|
executed.
|
|
|
|
pszQuery: query in restricted SQL WHERE format, or NULL to clear the
|
|
current query.
|
|
|
|
OGRERR_NONE if successfully installed, or an error code if the query
|
|
expression is in error, or some other failure occurs.
|
|
"""
|
|
return _ogr.Layer_SetAttributeFilter(self, *args)
|
|
|
|
|
|
def ResetReading(self, *args):
|
|
"""
|
|
ResetReading(Layer self)
|
|
|
|
void
|
|
OGR_L_ResetReading(OGRLayerH hLayer)
|
|
|
|
Reset feature reading to start on the first feature.
|
|
|
|
This affects GetNextFeature().
|
|
|
|
This function is the same as the C++ method OGRLayer::ResetReading().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hLayer: handle to the layer on which features are read.
|
|
"""
|
|
return _ogr.Layer_ResetReading(self, *args)
|
|
|
|
|
|
def GetName(self, *args):
|
|
"""
|
|
GetName(Layer self) -> char const *
|
|
|
|
const char* OGR_L_GetName(OGRLayerH
|
|
hLayer)
|
|
|
|
Return the layer name.
|
|
|
|
This returns the same content as
|
|
OGR_FD_GetName(OGR_L_GetLayerDefn(hLayer)), but for a few drivers,
|
|
calling OGR_L_GetName() directly can avoid lengthy layer definition
|
|
initialization.
|
|
|
|
This function is the same as the C++ method OGRLayer::GetName().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hLayer: handle to the layer.
|
|
|
|
the layer name (must not been freed)
|
|
|
|
OGR 1.8.0
|
|
"""
|
|
return _ogr.Layer_GetName(self, *args)
|
|
|
|
|
|
def GetGeomType(self, *args):
|
|
"""
|
|
GetGeomType(Layer self) -> OGRwkbGeometryType
|
|
|
|
OGRwkbGeometryType
|
|
OGR_L_GetGeomType(OGRLayerH hLayer)
|
|
|
|
Return the layer geometry type.
|
|
|
|
This returns the same result as
|
|
OGR_FD_GetGeomType(OGR_L_GetLayerDefn(hLayer)), but for a few drivers,
|
|
calling OGR_L_GetGeomType() directly can avoid lengthy layer
|
|
definition initialization.
|
|
|
|
For layers with multiple geometry fields, this method only returns the
|
|
geometry type of the first geometry column. For other columns, use
|
|
OGR_GFld_GetType(OGR_FD_GetGeomFieldDefn(OGR_L_GetLayerDefn(hLayer),
|
|
i)). For layers without any geometry field, this method returns
|
|
wkbNone.
|
|
|
|
This function is the same as the C++ method OGRLayer::GetGeomType().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hLayer: handle to the layer.
|
|
|
|
the geometry type
|
|
|
|
OGR 1.8.0
|
|
"""
|
|
return _ogr.Layer_GetGeomType(self, *args)
|
|
|
|
|
|
def GetGeometryColumn(self, *args):
|
|
"""
|
|
GetGeometryColumn(Layer self) -> char const *
|
|
|
|
const char*
|
|
OGR_L_GetGeometryColumn(OGRLayerH hLayer)
|
|
|
|
This method returns the name of the underlying database column being
|
|
used as the geometry column, or "" if not supported.
|
|
|
|
For layers with multiple geometry fields, this method only returns the
|
|
geometry type of the first geometry column. For other columns, use OGR
|
|
_GFld_GetNameRef(OGR_FD_GetGeomFieldDefn(OGR_L_GetLayerDefn(hLayer),
|
|
i)).
|
|
|
|
This method is the same as the C++ method
|
|
OGRLayer::GetGeometryColumn()
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hLayer: handle to the layer
|
|
|
|
geometry column name.
|
|
"""
|
|
return _ogr.Layer_GetGeometryColumn(self, *args)
|
|
|
|
|
|
def GetFIDColumn(self, *args):
|
|
"""
|
|
GetFIDColumn(Layer self) -> char const *
|
|
|
|
const char*
|
|
OGR_L_GetFIDColumn(OGRLayerH hLayer)
|
|
|
|
This method returns the name of the underlying database column being
|
|
used as the FID column, or "" if not supported.
|
|
|
|
This method is the same as the C++ method OGRLayer::GetFIDColumn()
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hLayer: handle to the layer
|
|
|
|
fid column name.
|
|
"""
|
|
return _ogr.Layer_GetFIDColumn(self, *args)
|
|
|
|
|
|
def GetFeature(self, *args):
|
|
"""
|
|
GetFeature(Layer self, GIntBig fid) -> Feature
|
|
|
|
OGRFeatureH
|
|
OGR_L_GetFeature(OGRLayerH hLayer, GIntBig nFeatureId)
|
|
|
|
Fetch a feature by its identifier.
|
|
|
|
This function will attempt to read the identified feature. The nFID
|
|
value cannot be OGRNullFID. Success or failure of this operation is
|
|
unaffected by the spatial or attribute filters (and specialized
|
|
implementations in drivers should make sure that they do not take into
|
|
account spatial or attribute filters).
|
|
|
|
If this function returns a non-NULL feature, it is guaranteed that its
|
|
feature id ( OGR_F_GetFID()) will be the same as nFID.
|
|
|
|
Use OGR_L_TestCapability(OLCRandomRead) to establish if this layer
|
|
supports efficient random access reading via OGR_L_GetFeature();
|
|
however, the call should always work if the feature exists as a
|
|
fallback implementation just scans all the features in the layer
|
|
looking for the desired feature.
|
|
|
|
Sequential reads (with OGR_L_GetNextFeature()) are generally
|
|
considered interrupted by a OGR_L_GetFeature() call.
|
|
|
|
The returned feature should be free with OGR_F_Destroy().
|
|
|
|
This function is the same as the C++ method OGRLayer::GetFeature( ).
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hLayer: handle to the layer that owned the feature.
|
|
|
|
nFeatureId: the feature id of the feature to read.
|
|
|
|
a handle to a feature now owned by the caller, or NULL on failure.
|
|
"""
|
|
return _ogr.Layer_GetFeature(self, *args)
|
|
|
|
|
|
def GetNextFeature(self, *args):
|
|
"""
|
|
GetNextFeature(Layer self) -> Feature
|
|
|
|
OGRFeatureH
|
|
OGR_L_GetNextFeature(OGRLayerH hLayer)
|
|
|
|
Fetch the next available feature from this layer.
|
|
|
|
The returned feature becomes the responsibility of the caller to
|
|
delete with OGR_F_Destroy(). It is critical that all features
|
|
associated with an OGRLayer (more specifically an OGRFeatureDefn) be
|
|
deleted before that layer/datasource is deleted.
|
|
|
|
Only features matching the current spatial filter (set with
|
|
SetSpatialFilter()) will be returned.
|
|
|
|
This function implements sequential access to the features of a layer.
|
|
The OGR_L_ResetReading() function can be used to start at the
|
|
beginning again.
|
|
|
|
Features returned by OGR_GetNextFeature() may or may not be affected
|
|
by concurrent modifications depending on drivers. A guaranteed way of
|
|
seeing modifications in effect is to call OGR_L_ResetReading() on
|
|
layers where OGR_GetNextFeature() has been called, before reading
|
|
again. Structural changes in layers (field addition, deletion, ...)
|
|
when a read is in progress may or may not be possible depending on
|
|
drivers. If a transaction is committed/aborted, the current sequential
|
|
reading may or may not be valid after that operation and a call to
|
|
OGR_L_ResetReading() might be needed.
|
|
|
|
This function is the same as the C++ method
|
|
OGRLayer::GetNextFeature().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hLayer: handle to the layer from which feature are read.
|
|
|
|
a handle to a feature, or NULL if no more features are available.
|
|
"""
|
|
return _ogr.Layer_GetNextFeature(self, *args)
|
|
|
|
|
|
def SetNextByIndex(self, *args):
|
|
"""
|
|
SetNextByIndex(Layer self, GIntBig new_index) -> OGRErr
|
|
|
|
OGRErr
|
|
OGR_L_SetNextByIndex(OGRLayerH hLayer, GIntBig nIndex)
|
|
|
|
Move read cursor to the nIndex'th feature in the current resultset.
|
|
|
|
This method allows positioning of a layer such that the
|
|
GetNextFeature() call will read the requested feature, where nIndex is
|
|
an absolute index into the current result set. So, setting it to 3
|
|
would mean the next feature read with GetNextFeature() would have been
|
|
the 4th feature to have been read if sequential reading took place
|
|
from the beginning of the layer, including accounting for spatial and
|
|
attribute filters.
|
|
|
|
Only in rare circumstances is SetNextByIndex() efficiently
|
|
implemented. In all other cases the default implementation which calls
|
|
ResetReading() and then calls GetNextFeature() nIndex times is used.
|
|
To determine if fast seeking is available on the current layer use the
|
|
TestCapability() method with a value of OLCFastSetNextByIndex.
|
|
|
|
This method is the same as the C++ method OGRLayer::SetNextByIndex()
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hLayer: handle to the layer
|
|
|
|
nIndex: the index indicating how many steps into the result set to
|
|
seek.
|
|
|
|
OGRERR_NONE on success or an error code.
|
|
"""
|
|
return _ogr.Layer_SetNextByIndex(self, *args)
|
|
|
|
|
|
def SetFeature(self, *args):
|
|
"""
|
|
SetFeature(Layer self, Feature feature) -> OGRErr
|
|
|
|
OGRErr OGR_L_SetFeature(OGRLayerH
|
|
hLayer, OGRFeatureH hFeat)
|
|
|
|
Rewrite an existing feature.
|
|
|
|
This function will write a feature to the layer, based on the feature
|
|
id within the OGRFeature.
|
|
|
|
Use OGR_L_TestCapability(OLCRandomWrite) to establish if this layer
|
|
supports random access writing via OGR_L_SetFeature().
|
|
|
|
This function is the same as the C++ method OGRLayer::SetFeature().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hLayer: handle to the layer to write the feature.
|
|
|
|
hFeat: the feature to write.
|
|
|
|
OGRERR_NONE if the operation works, otherwise an appropriate error
|
|
code (e.g OGRERR_NON_EXISTING_FEATURE if the feature does not exist).
|
|
|
|
"""
|
|
return _ogr.Layer_SetFeature(self, *args)
|
|
|
|
|
|
def CreateFeature(self, *args):
|
|
"""
|
|
CreateFeature(Layer self, Feature feature) -> OGRErr
|
|
|
|
OGRErr
|
|
OGR_L_CreateFeature(OGRLayerH hLayer, OGRFeatureH hFeat)
|
|
|
|
Create and write a new feature within a layer.
|
|
|
|
The passed feature is written to the layer as a new feature, rather
|
|
than overwriting an existing one. If the feature has a feature id
|
|
other than OGRNullFID, then the native implementation may use that as
|
|
the feature id of the new feature, but not necessarily. Upon
|
|
successful return the passed feature will have been updated with the
|
|
new feature id.
|
|
|
|
This function is the same as the C++ method OGRLayer::CreateFeature().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hLayer: handle to the layer to write the feature to.
|
|
|
|
hFeat: the handle of the feature to write to disk.
|
|
|
|
OGRERR_NONE on success.
|
|
"""
|
|
return _ogr.Layer_CreateFeature(self, *args)
|
|
|
|
|
|
def DeleteFeature(self, *args):
|
|
"""
|
|
DeleteFeature(Layer self, GIntBig fid) -> OGRErr
|
|
|
|
OGRErr
|
|
OGR_L_DeleteFeature(OGRLayerH hLayer, GIntBig nFID)
|
|
|
|
Delete feature from layer.
|
|
|
|
The feature with the indicated feature id is deleted from the layer if
|
|
supported by the driver. Most drivers do not support feature deletion,
|
|
and will return OGRERR_UNSUPPORTED_OPERATION. The
|
|
OGR_L_TestCapability() function may be called with OLCDeleteFeature to
|
|
check if the driver supports feature deletion.
|
|
|
|
This method is the same as the C++ method OGRLayer::DeleteFeature().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hLayer: handle to the layer
|
|
|
|
nFID: the feature id to be deleted from the layer
|
|
|
|
OGRERR_NONE if the operation works, otherwise an appropriate error
|
|
code (e.g OGRERR_NON_EXISTING_FEATURE if the feature does not exist).
|
|
|
|
"""
|
|
return _ogr.Layer_DeleteFeature(self, *args)
|
|
|
|
|
|
def SyncToDisk(self, *args):
|
|
"""
|
|
SyncToDisk(Layer self) -> OGRErr
|
|
|
|
OGRErr OGR_L_SyncToDisk(OGRLayerH
|
|
hLayer)
|
|
|
|
Flush pending changes to disk.
|
|
|
|
This call is intended to force the layer to flush any pending writes
|
|
to disk, and leave the disk file in a consistent state. It would not
|
|
normally have any effect on read-only datasources.
|
|
|
|
Some layers do not implement this method, and will still return
|
|
OGRERR_NONE. The default implementation just returns OGRERR_NONE. An
|
|
error is only returned if an error occurs while attempting to flush to
|
|
disk.
|
|
|
|
In any event, you should always close any opened datasource with
|
|
OGR_DS_Destroy() that will ensure all data is correctly flushed.
|
|
|
|
This method is the same as the C++ method OGRLayer::SyncToDisk()
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hLayer: handle to the layer
|
|
|
|
OGRERR_NONE if no error occurs (even if nothing is done) or an error
|
|
code.
|
|
"""
|
|
return _ogr.Layer_SyncToDisk(self, *args)
|
|
|
|
|
|
def GetLayerDefn(self, *args):
|
|
"""
|
|
GetLayerDefn(Layer self) -> FeatureDefn
|
|
|
|
OGRFeatureDefnH
|
|
OGR_L_GetLayerDefn(OGRLayerH hLayer)
|
|
|
|
Fetch the schema information for this layer.
|
|
|
|
The returned handle to the OGRFeatureDefn is owned by the OGRLayer,
|
|
and should not be modified or freed by the application. It
|
|
encapsulates the attribute schema of the features of the layer.
|
|
|
|
This function is the same as the C++ method OGRLayer::GetLayerDefn().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hLayer: handle to the layer to get the schema information.
|
|
|
|
a handle to the feature definition.
|
|
"""
|
|
return _ogr.Layer_GetLayerDefn(self, *args)
|
|
|
|
|
|
def GetFeatureCount(self, *args, **kwargs):
|
|
"""
|
|
GetFeatureCount(Layer self, int force=1) -> GIntBig
|
|
|
|
GIntBig
|
|
OGR_L_GetFeatureCount(OGRLayerH hLayer, int bForce)
|
|
|
|
Fetch the feature count in this layer.
|
|
|
|
Returns the number of features in the layer. For dynamic databases the
|
|
count may not be exact. If bForce is FALSE, and it would be expensive
|
|
to establish the feature count a value of -1 may be returned
|
|
indicating that the count isn't know. If bForce is TRUE some
|
|
implementations will actually scan the entire layer once to count
|
|
objects.
|
|
|
|
The returned count takes the spatial filter into account.
|
|
|
|
Note that some implementations of this method may alter the read
|
|
cursor of the layer.
|
|
|
|
This function is the same as the CPP OGRLayer::GetFeatureCount().
|
|
|
|
Note: since GDAL 2.0, this method returns a GIntBig (previously a int)
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hLayer: handle to the layer that owned the features.
|
|
|
|
bForce: Flag indicating whether the count should be computed even if
|
|
it is expensive.
|
|
|
|
feature count, -1 if count not known.
|
|
"""
|
|
return _ogr.Layer_GetFeatureCount(self, *args, **kwargs)
|
|
|
|
|
|
def GetExtent(self, *args, **kwargs):
|
|
"""
|
|
GetExtent(Layer self, int force=1, int can_return_null=0, int geom_field=0)
|
|
|
|
OGRErr OGR_L_GetExtent(OGRLayerH
|
|
hLayer, OGREnvelope *psExtent, int bForce)
|
|
|
|
Fetch the extent of this layer.
|
|
|
|
Returns the extent (MBR) of the data in the layer. If bForce is FALSE,
|
|
and it would be expensive to establish the extent then OGRERR_FAILURE
|
|
will be returned indicating that the extent isn't know. If bForce is
|
|
TRUE then some implementations will actually scan the entire layer
|
|
once to compute the MBR of all the features in the layer.
|
|
|
|
Depending on the drivers, the returned extent may or may not take the
|
|
spatial filter into account. So it is safer to call OGR_L_GetExtent()
|
|
without setting a spatial filter.
|
|
|
|
Layers without any geometry may return OGRERR_FAILURE just indicating
|
|
that no meaningful extents could be collected.
|
|
|
|
Note that some implementations of this method may alter the read
|
|
cursor of the layer.
|
|
|
|
This function is the same as the C++ method OGRLayer::GetExtent().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hLayer: handle to the layer from which to get extent.
|
|
|
|
psExtent: the structure in which the extent value will be returned.
|
|
|
|
bForce: Flag indicating whether the extent should be computed even if
|
|
it is expensive.
|
|
|
|
OGRERR_NONE on success, OGRERR_FAILURE if extent not known.
|
|
"""
|
|
return _ogr.Layer_GetExtent(self, *args, **kwargs)
|
|
|
|
|
|
def TestCapability(self, *args):
|
|
"""
|
|
TestCapability(Layer self, char const * cap) -> bool
|
|
|
|
int
|
|
OGR_L_TestCapability(OGRLayerH hLayer, const char *pszCap)
|
|
|
|
Test if this layer supported the named capability.
|
|
|
|
The capability codes that can be tested are represented as strings,
|
|
but #defined constants exists to ensure correct spelling. Specific
|
|
layer types may implement class specific capabilities, but this can't
|
|
generally be discovered by the caller.
|
|
|
|
OLCRandomRead / "RandomRead": TRUE if the GetFeature() method is
|
|
implemented in an optimized way for this layer, as opposed to the
|
|
default implementation using ResetReading() and GetNextFeature() to
|
|
find the requested feature id.
|
|
|
|
OLCSequentialWrite / "SequentialWrite": TRUE if the CreateFeature()
|
|
method works for this layer. Note this means that this particular
|
|
layer is writable. The same OGRLayer class may returned FALSE for
|
|
other layer instances that are effectively read-only.
|
|
|
|
OLCRandomWrite / "RandomWrite": TRUE if the SetFeature() method is
|
|
operational on this layer. Note this means that this particular layer
|
|
is writable. The same OGRLayer class may returned FALSE for other
|
|
layer instances that are effectively read-only.
|
|
|
|
OLCFastSpatialFilter / "FastSpatialFilter": TRUE if this layer
|
|
implements spatial filtering efficiently. Layers that effectively read
|
|
all features, and test them with the OGRFeature intersection methods
|
|
should return FALSE. This can be used as a clue by the application
|
|
whether it should build and maintain its own spatial index for
|
|
features in this layer.
|
|
|
|
OLCFastFeatureCount / "FastFeatureCount": TRUE if this layer can
|
|
return a feature count (via OGR_L_GetFeatureCount()) efficiently, i.e.
|
|
without counting the features. In some cases this will return TRUE
|
|
until a spatial filter is installed after which it will return FALSE.
|
|
|
|
OLCFastGetExtent / "FastGetExtent": TRUE if this layer can return
|
|
its data extent (via OGR_L_GetExtent()) efficiently, i.e. without
|
|
scanning all the features. In some cases this will return TRUE until a
|
|
spatial filter is installed after which it will return FALSE.
|
|
|
|
OLCFastSetNextByIndex / "FastSetNextByIndex": TRUE if this layer can
|
|
perform the SetNextByIndex() call efficiently, otherwise FALSE.
|
|
|
|
OLCCreateField / "CreateField": TRUE if this layer can create new
|
|
fields on the current layer using CreateField(), otherwise FALSE.
|
|
|
|
OLCCreateGeomField / "CreateGeomField": (GDAL >= 1.11) TRUE if this
|
|
layer can create new geometry fields on the current layer using
|
|
CreateGeomField(), otherwise FALSE.
|
|
|
|
OLCDeleteField / "DeleteField": TRUE if this layer can delete
|
|
existing fields on the current layer using DeleteField(), otherwise
|
|
FALSE.
|
|
|
|
OLCReorderFields / "ReorderFields": TRUE if this layer can reorder
|
|
existing fields on the current layer using ReorderField() or
|
|
ReorderFields(), otherwise FALSE.
|
|
|
|
OLCAlterFieldDefn / "AlterFieldDefn": TRUE if this layer can alter
|
|
the definition of an existing field on the current layer using
|
|
AlterFieldDefn(), otherwise FALSE.
|
|
|
|
OLCDeleteFeature / "DeleteFeature": TRUE if the DeleteFeature()
|
|
method is supported on this layer, otherwise FALSE.
|
|
|
|
OLCStringsAsUTF8 / "StringsAsUTF8": TRUE if values of OFTString
|
|
fields are assured to be in UTF-8 format. If FALSE the encoding of
|
|
fields is uncertain, though it might still be UTF-8.
|
|
|
|
OLCTransactions / "Transactions": TRUE if the StartTransaction(),
|
|
CommitTransaction() and RollbackTransaction() methods work in a
|
|
meaningful way, otherwise FALSE.
|
|
|
|
OLCCurveGeometries / "CurveGeometries": TRUE if this layer supports
|
|
writing curve geometries or may return such geometries. (GDAL 2.0).
|
|
|
|
This function is the same as the C++ method
|
|
OGRLayer::TestCapability().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hLayer: handle to the layer to get the capability from.
|
|
|
|
pszCap: the name of the capability to test.
|
|
|
|
TRUE if the layer has the requested capability, or FALSE otherwise.
|
|
OGRLayers will return FALSE for any unrecognized capabilities.
|
|
"""
|
|
return _ogr.Layer_TestCapability(self, *args)
|
|
|
|
|
|
def CreateField(self, *args, **kwargs):
|
|
"""
|
|
CreateField(Layer self, FieldDefn field_def, int approx_ok=1) -> OGRErr
|
|
|
|
OGRErr
|
|
OGR_L_CreateField(OGRLayerH hLayer, OGRFieldDefnH hField, int
|
|
bApproxOK)
|
|
|
|
Create a new field on a layer.
|
|
|
|
You must use this to create new fields on a real layer. Internally the
|
|
OGRFeatureDefn for the layer will be updated to reflect the new field.
|
|
Applications should never modify the OGRFeatureDefn used by a layer
|
|
directly.
|
|
|
|
This function should not be called while there are feature objects in
|
|
existence that were obtained or created with the previous layer
|
|
definition.
|
|
|
|
Not all drivers support this function. You can query a layer to check
|
|
if it supports it with the OLCCreateField capability. Some drivers may
|
|
only support this method while there are still no features in the
|
|
layer. When it is supported, the existing features of the backing
|
|
file/database should be updated accordingly.
|
|
|
|
Drivers may or may not support not-null constraints. If they support
|
|
creating fields with not-null constraints, this is generally before
|
|
creating any feature to the layer.
|
|
|
|
This function is the same as the C++ method OGRLayer::CreateField().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hLayer: handle to the layer to write the field definition.
|
|
|
|
hField: handle of the field definition to write to disk.
|
|
|
|
bApproxOK: If TRUE, the field may be created in a slightly different
|
|
form depending on the limitations of the format driver.
|
|
|
|
OGRERR_NONE on success.
|
|
"""
|
|
return _ogr.Layer_CreateField(self, *args, **kwargs)
|
|
|
|
|
|
def DeleteField(self, *args):
|
|
"""
|
|
DeleteField(Layer self, int iField) -> OGRErr
|
|
|
|
OGRErr
|
|
OGR_L_DeleteField(OGRLayerH hLayer, int iField)
|
|
|
|
Delete an existing field on a layer.
|
|
|
|
You must use this to delete existing fields on a real layer.
|
|
Internally the OGRFeatureDefn for the layer will be updated to reflect
|
|
the deleted field. Applications should never modify the OGRFeatureDefn
|
|
used by a layer directly.
|
|
|
|
This function should not be called while there are feature objects in
|
|
existence that were obtained or created with the previous layer
|
|
definition.
|
|
|
|
Not all drivers support this function. You can query a layer to check
|
|
if it supports it with the OLCDeleteField capability. Some drivers may
|
|
only support this method while there are still no features in the
|
|
layer. When it is supported, the existing features of the backing
|
|
file/database should be updated accordingly.
|
|
|
|
This function is the same as the C++ method OGRLayer::DeleteField().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hLayer: handle to the layer.
|
|
|
|
iField: index of the field to delete.
|
|
|
|
OGRERR_NONE on success.
|
|
|
|
OGR 1.9.0
|
|
"""
|
|
return _ogr.Layer_DeleteField(self, *args)
|
|
|
|
|
|
def ReorderField(self, *args):
|
|
"""
|
|
ReorderField(Layer self, int iOldFieldPos, int iNewFieldPos) -> OGRErr
|
|
|
|
OGRErr
|
|
OGR_L_ReorderField(OGRLayerH hLayer, int iOldFieldPos, int
|
|
iNewFieldPos)
|
|
|
|
Reorder an existing field on a layer.
|
|
|
|
This function is a convenience wrapper of OGR_L_ReorderFields()
|
|
dedicated to move a single field.
|
|
|
|
You must use this to reorder existing fields on a real layer.
|
|
Internally the OGRFeatureDefn for the layer will be updated to reflect
|
|
the reordering of the fields. Applications should never modify the
|
|
OGRFeatureDefn used by a layer directly.
|
|
|
|
This function should not be called while there are feature objects in
|
|
existence that were obtained or created with the previous layer
|
|
definition.
|
|
|
|
The field definition that was at initial position iOldFieldPos will be
|
|
moved at position iNewFieldPos, and elements between will be shuffled
|
|
accordingly.
|
|
|
|
For example, let suppose the fields were "0","1","2","3","4"
|
|
initially. ReorderField(1, 3) will reorder them as
|
|
"0","2","3","1","4".
|
|
|
|
Not all drivers support this function. You can query a layer to check
|
|
if it supports it with the OLCReorderFields capability. Some drivers
|
|
may only support this method while there are still no features in the
|
|
layer. When it is supported, the existing features of the backing
|
|
file/database should be updated accordingly.
|
|
|
|
This function is the same as the C++ method OGRLayer::ReorderField().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hLayer: handle to the layer.
|
|
|
|
iOldFieldPos: previous position of the field to move. Must be in the
|
|
range [0,GetFieldCount()-1].
|
|
|
|
iNewFieldPos: new position of the field to move. Must be in the range
|
|
[0,GetFieldCount()-1].
|
|
|
|
OGRERR_NONE on success.
|
|
|
|
OGR 1.9.0
|
|
"""
|
|
return _ogr.Layer_ReorderField(self, *args)
|
|
|
|
|
|
def ReorderFields(self, *args):
|
|
"""
|
|
ReorderFields(Layer self, int nList) -> OGRErr
|
|
|
|
OGRErr
|
|
OGR_L_ReorderFields(OGRLayerH hLayer, int *panMap)
|
|
|
|
Reorder all the fields of a layer.
|
|
|
|
You must use this to reorder existing fields on a real layer.
|
|
Internally the OGRFeatureDefn for the layer will be updated to reflect
|
|
the reordering of the fields. Applications should never modify the
|
|
OGRFeatureDefn used by a layer directly.
|
|
|
|
This function should not be called while there are feature objects in
|
|
existence that were obtained or created with the previous layer
|
|
definition.
|
|
|
|
panMap is such that,for each field definition at position i after
|
|
reordering, its position before reordering was panMap[i].
|
|
|
|
For example, let suppose the fields were "0","1","2","3","4"
|
|
initially. ReorderFields([0,2,3,1,4]) will reorder them as
|
|
"0","2","3","1","4".
|
|
|
|
Not all drivers support this function. You can query a layer to check
|
|
if it supports it with the OLCReorderFields capability. Some drivers
|
|
may only support this method while there are still no features in the
|
|
layer. When it is supported, the existing features of the backing
|
|
file/database should be updated accordingly.
|
|
|
|
This function is the same as the C++ method OGRLayer::ReorderFields().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hLayer: handle to the layer.
|
|
|
|
panMap: an array of GetLayerDefn()-> OGRFeatureDefn::GetFieldCount()
|
|
elements which is a permutation of [0, GetLayerDefn()->
|
|
OGRFeatureDefn::GetFieldCount()-1].
|
|
|
|
OGRERR_NONE on success.
|
|
|
|
OGR 1.9.0
|
|
"""
|
|
return _ogr.Layer_ReorderFields(self, *args)
|
|
|
|
|
|
def AlterFieldDefn(self, *args):
|
|
"""
|
|
AlterFieldDefn(Layer self, int iField, FieldDefn field_def, int nFlags) -> OGRErr
|
|
|
|
OGRErr
|
|
OGR_L_AlterFieldDefn(OGRLayerH hLayer, int iField, OGRFieldDefnH
|
|
hNewFieldDefn, int nFlags)
|
|
|
|
Alter the definition of an existing field on a layer.
|
|
|
|
You must use this to alter the definition of an existing field of a
|
|
real layer. Internally the OGRFeatureDefn for the layer will be
|
|
updated to reflect the altered field. Applications should never modify
|
|
the OGRFeatureDefn used by a layer directly.
|
|
|
|
This function should not be called while there are feature objects in
|
|
existence that were obtained or created with the previous layer
|
|
definition.
|
|
|
|
Not all drivers support this function. You can query a layer to check
|
|
if it supports it with the OLCAlterFieldDefn capability. Some drivers
|
|
may only support this method while there are still no features in the
|
|
layer. When it is supported, the existing features of the backing
|
|
file/database should be updated accordingly. Some drivers might also
|
|
not support all update flags.
|
|
|
|
This function is the same as the C++ method
|
|
OGRLayer::AlterFieldDefn().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hLayer: handle to the layer.
|
|
|
|
iField: index of the field whose definition must be altered.
|
|
|
|
hNewFieldDefn: new field definition
|
|
|
|
nFlags: combination of ALTER_NAME_FLAG, ALTER_TYPE_FLAG,
|
|
ALTER_WIDTH_PRECISION_FLAG, ALTER_NULLABLE_FLAG and ALTER_DEFAULT_FLAG
|
|
to indicate which of the name and/or type and/or width and precision
|
|
fields and/or nullability from the new field definition must be taken
|
|
into account.
|
|
|
|
OGRERR_NONE on success.
|
|
|
|
OGR 1.9.0
|
|
"""
|
|
return _ogr.Layer_AlterFieldDefn(self, *args)
|
|
|
|
|
|
def CreateGeomField(self, *args, **kwargs):
|
|
"""
|
|
CreateGeomField(Layer self, GeomFieldDefn field_def, int approx_ok=1) -> OGRErr
|
|
|
|
OGRErr
|
|
OGR_L_CreateGeomField(OGRLayerH hLayer, OGRGeomFieldDefnH hField, int
|
|
bApproxOK)
|
|
|
|
Create a new geometry field on a layer.
|
|
|
|
You must use this to create new geometry fields on a real layer.
|
|
Internally the OGRFeatureDefn for the layer will be updated to reflect
|
|
the new field. Applications should never modify the OGRFeatureDefn
|
|
used by a layer directly.
|
|
|
|
This function should not be called while there are feature objects in
|
|
existence that were obtained or created with the previous layer
|
|
definition.
|
|
|
|
Not all drivers support this function. You can query a layer to check
|
|
if it supports it with the OLCCreateField capability. Some drivers may
|
|
only support this method while there are still no features in the
|
|
layer. When it is supported, the existing features of the backing
|
|
file/database should be updated accordingly.
|
|
|
|
Drivers may or may not support not-null constraints. If they support
|
|
creating fields with not-null constraints, this is generally before
|
|
creating any feature to the layer.
|
|
|
|
This function is the same as the C++ method OGRLayer::CreateField().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hLayer: handle to the layer to write the field definition.
|
|
|
|
hField: handle of the geometry field definition to write to disk.
|
|
|
|
bApproxOK: If TRUE, the field may be created in a slightly different
|
|
form depending on the limitations of the format driver.
|
|
|
|
OGRERR_NONE on success.
|
|
|
|
OGR 1.11
|
|
"""
|
|
return _ogr.Layer_CreateGeomField(self, *args, **kwargs)
|
|
|
|
|
|
def StartTransaction(self, *args):
|
|
"""
|
|
StartTransaction(Layer self) -> OGRErr
|
|
|
|
OGRErr
|
|
OGR_L_StartTransaction(OGRLayerH hLayer)
|
|
|
|
For datasources which support transactions, StartTransaction creates a
|
|
transaction.
|
|
|
|
If starting the transaction fails, will return OGRERR_FAILURE.
|
|
Datasources which do not support transactions will always return
|
|
OGRERR_NONE.
|
|
|
|
Note: as of GDAL 2.0, use of this API is discouraged when the dataset
|
|
offers dataset level transaction with GDALDataset::StartTransaction().
|
|
The reason is that most drivers can only offer transactions at dataset
|
|
level, and not layer level. Very few drivers really support
|
|
transactions at layer scope.
|
|
|
|
This function is the same as the C++ method
|
|
OGRLayer::StartTransaction().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hLayer: handle to the layer
|
|
|
|
OGRERR_NONE on success.
|
|
"""
|
|
return _ogr.Layer_StartTransaction(self, *args)
|
|
|
|
|
|
def CommitTransaction(self, *args):
|
|
"""
|
|
CommitTransaction(Layer self) -> OGRErr
|
|
|
|
OGRErr
|
|
OGR_L_CommitTransaction(OGRLayerH hLayer)
|
|
|
|
For datasources which support transactions, CommitTransaction commits
|
|
a transaction.
|
|
|
|
If no transaction is active, or the commit fails, will return
|
|
OGRERR_FAILURE. Datasources which do not support transactions will
|
|
always return OGRERR_NONE.
|
|
|
|
This function is the same as the C++ method
|
|
OGRLayer::CommitTransaction().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hLayer: handle to the layer
|
|
|
|
OGRERR_NONE on success.
|
|
"""
|
|
return _ogr.Layer_CommitTransaction(self, *args)
|
|
|
|
|
|
def RollbackTransaction(self, *args):
|
|
"""
|
|
RollbackTransaction(Layer self) -> OGRErr
|
|
|
|
OGRErr
|
|
OGR_L_RollbackTransaction(OGRLayerH hLayer)
|
|
|
|
For datasources which support transactions, RollbackTransaction will
|
|
roll back a datasource to its state before the start of the current
|
|
transaction.
|
|
|
|
If no transaction is active, or the rollback fails, will return
|
|
OGRERR_FAILURE. Datasources which do not support transactions will
|
|
always return OGRERR_NONE.
|
|
|
|
This function is the same as the C++ method
|
|
OGRLayer::RollbackTransaction().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hLayer: handle to the layer
|
|
|
|
OGRERR_NONE on success.
|
|
"""
|
|
return _ogr.Layer_RollbackTransaction(self, *args)
|
|
|
|
|
|
def FindFieldIndex(self, *args):
|
|
"""
|
|
FindFieldIndex(Layer self, char const * pszFieldName, int bExactMatch) -> int
|
|
|
|
int
|
|
OGR_L_FindFieldIndex(OGRLayerH hLayer, const char *pszFieldName, int
|
|
bExactMatch)
|
|
|
|
Find the index of field in a layer.
|
|
|
|
The returned number is the index of the field in the layers, or -1 if
|
|
the field doesn't exist.
|
|
|
|
If bExactMatch is set to FALSE and the field doesn't exists in the
|
|
given form the driver might apply some changes to make it match, like
|
|
those it might do if the layer was created (eg. like LAUNDER in the
|
|
OCI driver).
|
|
|
|
This method is the same as the C++ method OGRLayer::FindFieldIndex().
|
|
|
|
field index, or -1 if the field doesn't exist
|
|
"""
|
|
return _ogr.Layer_FindFieldIndex(self, *args)
|
|
|
|
|
|
def GetSpatialRef(self, *args):
|
|
"""
|
|
GetSpatialRef(Layer self) -> SpatialReference
|
|
|
|
OGRSpatialReferenceH
|
|
OGR_L_GetSpatialRef(OGRLayerH hLayer)
|
|
|
|
Fetch the spatial reference system for this layer.
|
|
|
|
The returned object is owned by the OGRLayer and should not be
|
|
modified or freed by the application.
|
|
|
|
This function is the same as the C++ method OGRLayer::GetSpatialRef().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hLayer: handle to the layer to get the spatial reference from.
|
|
|
|
spatial reference, or NULL if there isn't one.
|
|
"""
|
|
return _ogr.Layer_GetSpatialRef(self, *args)
|
|
|
|
|
|
def GetFeaturesRead(self, *args):
|
|
"""
|
|
GetFeaturesRead(Layer self) -> GIntBig
|
|
|
|
GIntBig
|
|
OGR_L_GetFeaturesRead(OGRLayerH hLayer)
|
|
"""
|
|
return _ogr.Layer_GetFeaturesRead(self, *args)
|
|
|
|
|
|
def SetIgnoredFields(self, *args):
|
|
"""
|
|
SetIgnoredFields(Layer self, char const ** options) -> OGRErr
|
|
|
|
OGRErr
|
|
OGR_L_SetIgnoredFields(OGRLayerH hLayer, const char **papszFields)
|
|
|
|
Set which fields can be omitted when retrieving features from the
|
|
layer.
|
|
|
|
If the driver supports this functionality (testable using
|
|
OLCIgnoreFields capability), it will not fetch the specified fields in
|
|
subsequent calls to GetFeature() / GetNextFeature() and thus save some
|
|
processing time and/or bandwidth.
|
|
|
|
Besides field names of the layers, the following special fields can be
|
|
passed: "OGR_GEOMETRY" to ignore geometry and "OGR_STYLE" to
|
|
ignore layer style.
|
|
|
|
By default, no fields are ignored.
|
|
|
|
This method is the same as the C++ method OGRLayer::SetIgnoredFields()
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
papszFields: an array of field names terminated by NULL item. If NULL
|
|
is passed, the ignored list is cleared.
|
|
|
|
OGRERR_NONE if all field names have been resolved (even if the driver
|
|
does not support this method)
|
|
"""
|
|
return _ogr.Layer_SetIgnoredFields(self, *args)
|
|
|
|
|
|
def Intersection(self, *args, **kwargs):
|
|
"""
|
|
Intersection(Layer self, Layer method_layer, Layer result_layer, char ** options=None, GDALProgressFunc callback=0, void * callback_data=None) -> OGRErr
|
|
|
|
OGRErr
|
|
OGR_L_Intersection(OGRLayerH pLayerInput, OGRLayerH pLayerMethod,
|
|
OGRLayerH pLayerResult, char **papszOptions, GDALProgressFunc
|
|
pfnProgress, void *pProgressArg)
|
|
|
|
Intersection of two layers.
|
|
|
|
The result layer contains features whose geometries represent areas
|
|
that are common between features in the input layer and in the method
|
|
layer. The features in the result layer have attributes from both
|
|
input and method layers. The schema of the result layer can be set by
|
|
the user or, if it is empty, is initialized to contain all fields in
|
|
the input and method layers.
|
|
|
|
If the schema of the result is set by user and contains fields that
|
|
have the same name as a field in input and in method layer, then the
|
|
attribute in the result feature will get the value from the feature of
|
|
the method layer.
|
|
|
|
For best performance use the minimum amount of features in the method
|
|
layer and copy it into a memory layer.
|
|
|
|
This method relies on GEOS support. Do not use unless the GEOS support
|
|
is compiled in. The recognized list of options is :
|
|
SKIP_FAILURES=YES/NO. Set it to YES to go on, even when a feature
|
|
could not be inserted or a GEOS call failed.
|
|
|
|
PROMOTE_TO_MULTI=YES/NO. Set it to YES to convert Polygons into
|
|
MultiPolygons, or LineStrings to MultiLineStrings.
|
|
|
|
INPUT_PREFIX=string. Set a prefix for the field names that will be
|
|
created from the fields of the input layer.
|
|
|
|
METHOD_PREFIX=string. Set a prefix for the field names that will be
|
|
created from the fields of the method layer.
|
|
|
|
USE_PREPARED_GEOMETRIES=YES/NO. Set to NO to not use prepared
|
|
geometries to pretest intersection of features of method layer with
|
|
features of this layer.
|
|
|
|
PRETEST_CONTAINMENT=YES/NO. Set to YES to pretest the containment of
|
|
features of method layer within the features of this layer. This will
|
|
speed up the method significantly in some cases. Requires that the
|
|
prepared geometries are in effect.
|
|
|
|
KEEP_LOWER_DIMENSION_GEOMETRIES=YES/NO. Set to NO to skip result
|
|
features with lower dimension geometry that would otherwise be added
|
|
to the result layer. The default is to add but only if the result
|
|
layer has an unknown geometry type.
|
|
|
|
This function is the same as the C++ method OGRLayer::Intersection().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
pLayerInput: the input layer. Should not be NULL.
|
|
|
|
pLayerMethod: the method layer. Should not be NULL.
|
|
|
|
pLayerResult: the layer where the features resulting from the
|
|
operation are inserted. Should not be NULL. See above the note about
|
|
the schema.
|
|
|
|
papszOptions: NULL terminated list of options (may be NULL).
|
|
|
|
pfnProgress: a GDALProgressFunc() compatible callback function for
|
|
reporting progress or NULL.
|
|
|
|
pProgressArg: argument to be passed to pfnProgress. May be NULL.
|
|
|
|
an error code if there was an error or the execution was interrupted,
|
|
OGRERR_NONE otherwise.
|
|
|
|
The first geometry field is always used.
|
|
|
|
OGR 1.10
|
|
"""
|
|
return _ogr.Layer_Intersection(self, *args, **kwargs)
|
|
|
|
|
|
def Union(self, *args, **kwargs):
|
|
"""
|
|
Union(Layer self, Layer method_layer, Layer result_layer, char ** options=None, GDALProgressFunc callback=0, void * callback_data=None) -> OGRErr
|
|
|
|
OGRErr OGR_L_Union(OGRLayerH
|
|
pLayerInput, OGRLayerH pLayerMethod, OGRLayerH pLayerResult, char
|
|
**papszOptions, GDALProgressFunc pfnProgress, void *pProgressArg)
|
|
|
|
Union of two layers.
|
|
|
|
The result layer contains features whose geometries represent areas
|
|
that are in either in the input layer, in the method layer, or in
|
|
both. The features in the result layer have attributes from both input
|
|
and method layers. For features which represent areas that are only in
|
|
the input or in the method layer the respective attributes have
|
|
undefined values. The schema of the result layer can be set by the
|
|
user or, if it is empty, is initialized to contain all fields in the
|
|
input and method layers.
|
|
|
|
If the schema of the result is set by user and contains fields that
|
|
have the same name as a field in input and in method layer, then the
|
|
attribute in the result feature will get the value from the feature of
|
|
the method layer (even if it is undefined).
|
|
|
|
For best performance use the minimum amount of features in the method
|
|
layer and copy it into a memory layer.
|
|
|
|
This method relies on GEOS support. Do not use unless the GEOS support
|
|
is compiled in. The recognized list of options is :
|
|
SKIP_FAILURES=YES/NO. Set it to YES to go on, even when a feature
|
|
could not be inserted or a GEOS call failed.
|
|
|
|
PROMOTE_TO_MULTI=YES/NO. Set it to YES to convert Polygons into
|
|
MultiPolygons, or LineStrings to MultiLineStrings.
|
|
|
|
INPUT_PREFIX=string. Set a prefix for the field names that will be
|
|
created from the fields of the input layer.
|
|
|
|
METHOD_PREFIX=string. Set a prefix for the field names that will be
|
|
created from the fields of the method layer.
|
|
|
|
USE_PREPARED_GEOMETRIES=YES/NO. Set to NO to not use prepared
|
|
geometries to pretest intersection of features of method layer with
|
|
features of this layer.
|
|
|
|
KEEP_LOWER_DIMENSION_GEOMETRIES=YES/NO. Set to NO to skip result
|
|
features with lower dimension geometry that would otherwise be added
|
|
to the result layer. The default is to add but only if the result
|
|
layer has an unknown geometry type.
|
|
|
|
This function is the same as the C++ method OGRLayer::Union().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
pLayerInput: the input layer. Should not be NULL.
|
|
|
|
pLayerMethod: the method layer. Should not be NULL.
|
|
|
|
pLayerResult: the layer where the features resulting from the
|
|
operation are inserted. Should not be NULL. See above the note about
|
|
the schema.
|
|
|
|
papszOptions: NULL terminated list of options (may be NULL).
|
|
|
|
pfnProgress: a GDALProgressFunc() compatible callback function for
|
|
reporting progress or NULL.
|
|
|
|
pProgressArg: argument to be passed to pfnProgress. May be NULL.
|
|
|
|
an error code if there was an error or the execution was interrupted,
|
|
OGRERR_NONE otherwise.
|
|
|
|
The first geometry field is always used.
|
|
|
|
OGR 1.10
|
|
"""
|
|
return _ogr.Layer_Union(self, *args, **kwargs)
|
|
|
|
|
|
def SymDifference(self, *args, **kwargs):
|
|
"""
|
|
SymDifference(Layer self, Layer method_layer, Layer result_layer, char ** options=None, GDALProgressFunc callback=0, void * callback_data=None) -> OGRErr
|
|
|
|
OGRErr
|
|
OGR_L_SymDifference(OGRLayerH pLayerInput, OGRLayerH pLayerMethod,
|
|
OGRLayerH pLayerResult, char **papszOptions, GDALProgressFunc
|
|
pfnProgress, void *pProgressArg)
|
|
|
|
Symmetrical difference of two layers.
|
|
|
|
The result layer contains features whose geometries represent areas
|
|
that are in either in the input layer or in the method layer but not
|
|
in both. The features in the result layer have attributes from both
|
|
input and method layers. For features which represent areas that are
|
|
only in the input or in the method layer the respective attributes
|
|
have undefined values. The schema of the result layer can be set by
|
|
the user or, if it is empty, is initialized to contain all fields in
|
|
the input and method layers.
|
|
|
|
If the schema of the result is set by user and contains fields that
|
|
have the same name as a field in input and in method layer, then the
|
|
attribute in the result feature will get the value from the feature of
|
|
the method layer (even if it is undefined).
|
|
|
|
For best performance use the minimum amount of features in the method
|
|
layer and copy it into a memory layer.
|
|
|
|
This method relies on GEOS support. Do not use unless the GEOS support
|
|
is compiled in. The recognized list of options is :
|
|
SKIP_FAILURES=YES/NO. Set it to YES to go on, even when a feature
|
|
could not be inserted or a GEOS call failed.
|
|
|
|
PROMOTE_TO_MULTI=YES/NO. Set it to YES to convert Polygons into
|
|
MultiPolygons, or LineStrings to MultiLineStrings.
|
|
|
|
INPUT_PREFIX=string. Set a prefix for the field names that will be
|
|
created from the fields of the input layer.
|
|
|
|
METHOD_PREFIX=string. Set a prefix for the field names that will be
|
|
created from the fields of the method layer.
|
|
|
|
This function is the same as the C++ method OGRLayer::SymDifference().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
pLayerInput: the input layer. Should not be NULL.
|
|
|
|
pLayerMethod: the method layer. Should not be NULL.
|
|
|
|
pLayerResult: the layer where the features resulting from the
|
|
operation are inserted. Should not be NULL. See above the note about
|
|
the schema.
|
|
|
|
papszOptions: NULL terminated list of options (may be NULL).
|
|
|
|
pfnProgress: a GDALProgressFunc() compatible callback function for
|
|
reporting progress or NULL.
|
|
|
|
pProgressArg: argument to be passed to pfnProgress. May be NULL.
|
|
|
|
an error code if there was an error or the execution was interrupted,
|
|
OGRERR_NONE otherwise.
|
|
|
|
The first geometry field is always used.
|
|
|
|
OGR 1.10
|
|
"""
|
|
return _ogr.Layer_SymDifference(self, *args, **kwargs)
|
|
|
|
|
|
def Identity(self, *args, **kwargs):
|
|
"""
|
|
Identity(Layer self, Layer method_layer, Layer result_layer, char ** options=None, GDALProgressFunc callback=0, void * callback_data=None) -> OGRErr
|
|
|
|
OGRErr OGR_L_Identity(OGRLayerH
|
|
pLayerInput, OGRLayerH pLayerMethod, OGRLayerH pLayerResult, char
|
|
**papszOptions, GDALProgressFunc pfnProgress, void *pProgressArg)
|
|
|
|
Identify the features of this layer with the ones from the identity
|
|
layer.
|
|
|
|
The result layer contains features whose geometries represent areas
|
|
that are in the input layer. The features in the result layer have
|
|
attributes from both input and method layers. The schema of the result
|
|
layer can be set by the user or, if it is empty, is initialized to
|
|
contain all fields in input and method layers.
|
|
|
|
If the schema of the result is set by user and contains fields that
|
|
have the same name as a field in input and in method layer, then the
|
|
attribute in the result feature will get the value from the feature of
|
|
the method layer (even if it is undefined).
|
|
|
|
For best performance use the minimum amount of features in the method
|
|
layer and copy it into a memory layer.
|
|
|
|
This method relies on GEOS support. Do not use unless the GEOS support
|
|
is compiled in. The recognized list of options is :
|
|
SKIP_FAILURES=YES/NO. Set it to YES to go on, even when a feature
|
|
could not be inserted or a GEOS call failed.
|
|
|
|
PROMOTE_TO_MULTI=YES/NO. Set it to YES to convert Polygons into
|
|
MultiPolygons, or LineStrings to MultiLineStrings.
|
|
|
|
INPUT_PREFIX=string. Set a prefix for the field names that will be
|
|
created from the fields of the input layer.
|
|
|
|
METHOD_PREFIX=string. Set a prefix for the field names that will be
|
|
created from the fields of the method layer.
|
|
|
|
USE_PREPARED_GEOMETRIES=YES/NO. Set to NO to not use prepared
|
|
geometries to pretest intersection of features of method layer with
|
|
features of this layer.
|
|
|
|
KEEP_LOWER_DIMENSION_GEOMETRIES=YES/NO. Set to NO to skip result
|
|
features with lower dimension geometry that would otherwise be added
|
|
to the result layer. The default is to add but only if the result
|
|
layer has an unknown geometry type.
|
|
|
|
This function is the same as the C++ method OGRLayer::Identity().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
pLayerInput: the input layer. Should not be NULL.
|
|
|
|
pLayerMethod: the method layer. Should not be NULL.
|
|
|
|
pLayerResult: the layer where the features resulting from the
|
|
operation are inserted. Should not be NULL. See above the note about
|
|
the schema.
|
|
|
|
papszOptions: NULL terminated list of options (may be NULL).
|
|
|
|
pfnProgress: a GDALProgressFunc() compatible callback function for
|
|
reporting progress or NULL.
|
|
|
|
pProgressArg: argument to be passed to pfnProgress. May be NULL.
|
|
|
|
an error code if there was an error or the execution was interrupted,
|
|
OGRERR_NONE otherwise.
|
|
|
|
The first geometry field is always used.
|
|
|
|
OGR 1.10
|
|
"""
|
|
return _ogr.Layer_Identity(self, *args, **kwargs)
|
|
|
|
|
|
def Update(self, *args, **kwargs):
|
|
"""
|
|
Update(Layer self, Layer method_layer, Layer result_layer, char ** options=None, GDALProgressFunc callback=0, void * callback_data=None) -> OGRErr
|
|
|
|
OGRErr OGR_L_Update(OGRLayerH
|
|
pLayerInput, OGRLayerH pLayerMethod, OGRLayerH pLayerResult, char
|
|
**papszOptions, GDALProgressFunc pfnProgress, void *pProgressArg)
|
|
|
|
Update this layer with features from the update layer.
|
|
|
|
The result layer contains features whose geometries represent areas
|
|
that are either in the input layer or in the method layer. The
|
|
features in the result layer have areas of the features of the method
|
|
layer or those ares of the features of the input layer that are not
|
|
covered by the method layer. The features of the result layer get
|
|
their attributes from the input layer. The schema of the result layer
|
|
can be set by the user or, if it is empty, is initialized to contain
|
|
all fields in the input layer.
|
|
|
|
If the schema of the result is set by user and contains fields that
|
|
have the same name as a field in the method layer, then the attribute
|
|
in the result feature the originates from the method layer will get
|
|
the value from the feature of the method layer.
|
|
|
|
For best performance use the minimum amount of features in the method
|
|
layer and copy it into a memory layer.
|
|
|
|
This method relies on GEOS support. Do not use unless the GEOS support
|
|
is compiled in. The recognized list of options is :
|
|
SKIP_FAILURES=YES/NO. Set it to YES to go on, even when a feature
|
|
could not be inserted or a GEOS call failed.
|
|
|
|
PROMOTE_TO_MULTI=YES/NO. Set it to YES to convert Polygons into
|
|
MultiPolygons, or LineStrings to MultiLineStrings.
|
|
|
|
INPUT_PREFIX=string. Set a prefix for the field names that will be
|
|
created from the fields of the input layer.
|
|
|
|
METHOD_PREFIX=string. Set a prefix for the field names that will be
|
|
created from the fields of the method layer.
|
|
|
|
This function is the same as the C++ method OGRLayer::Update().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
pLayerInput: the input layer. Should not be NULL.
|
|
|
|
pLayerMethod: the method layer. Should not be NULL.
|
|
|
|
pLayerResult: the layer where the features resulting from the
|
|
operation are inserted. Should not be NULL. See above the note about
|
|
the schema.
|
|
|
|
papszOptions: NULL terminated list of options (may be NULL).
|
|
|
|
pfnProgress: a GDALProgressFunc() compatible callback function for
|
|
reporting progress or NULL.
|
|
|
|
pProgressArg: argument to be passed to pfnProgress. May be NULL.
|
|
|
|
an error code if there was an error or the execution was interrupted,
|
|
OGRERR_NONE otherwise.
|
|
|
|
The first geometry field is always used.
|
|
|
|
OGR 1.10
|
|
"""
|
|
return _ogr.Layer_Update(self, *args, **kwargs)
|
|
|
|
|
|
def Clip(self, *args, **kwargs):
|
|
"""
|
|
Clip(Layer self, Layer method_layer, Layer result_layer, char ** options=None, GDALProgressFunc callback=0, void * callback_data=None) -> OGRErr
|
|
|
|
OGRErr OGR_L_Clip(OGRLayerH pLayerInput,
|
|
OGRLayerH pLayerMethod, OGRLayerH pLayerResult, char **papszOptions,
|
|
GDALProgressFunc pfnProgress, void *pProgressArg)
|
|
|
|
Clip off areas that are not covered by the method layer.
|
|
|
|
The result layer contains features whose geometries represent areas
|
|
that are in the input layer and in the method layer. The features in
|
|
the result layer have the (possibly clipped) areas of features in the
|
|
input layer and the attributes from the same features. The schema of
|
|
the result layer can be set by the user or, if it is empty, is
|
|
initialized to contain all fields in the input layer.
|
|
|
|
For best performance use the minimum amount of features in the method
|
|
layer and copy it into a memory layer.
|
|
|
|
This method relies on GEOS support. Do not use unless the GEOS support
|
|
is compiled in. The recognized list of options is :
|
|
SKIP_FAILURES=YES/NO. Set it to YES to go on, even when a feature
|
|
could not be inserted or a GEOS call failed.
|
|
|
|
PROMOTE_TO_MULTI=YES/NO. Set it to YES to convert Polygons into
|
|
MultiPolygons, or LineStrings to MultiLineStrings.
|
|
|
|
INPUT_PREFIX=string. Set a prefix for the field names that will be
|
|
created from the fields of the input layer.
|
|
|
|
METHOD_PREFIX=string. Set a prefix for the field names that will be
|
|
created from the fields of the method layer.
|
|
|
|
This function is the same as the C++ method OGRLayer::Clip().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
pLayerInput: the input layer. Should not be NULL.
|
|
|
|
pLayerMethod: the method layer. Should not be NULL.
|
|
|
|
pLayerResult: the layer where the features resulting from the
|
|
operation are inserted. Should not be NULL. See above the note about
|
|
the schema.
|
|
|
|
papszOptions: NULL terminated list of options (may be NULL).
|
|
|
|
pfnProgress: a GDALProgressFunc() compatible callback function for
|
|
reporting progress or NULL.
|
|
|
|
pProgressArg: argument to be passed to pfnProgress. May be NULL.
|
|
|
|
an error code if there was an error or the execution was interrupted,
|
|
OGRERR_NONE otherwise.
|
|
|
|
The first geometry field is always used.
|
|
|
|
OGR 1.10
|
|
"""
|
|
return _ogr.Layer_Clip(self, *args, **kwargs)
|
|
|
|
|
|
def Erase(self, *args, **kwargs):
|
|
"""
|
|
Erase(Layer self, Layer method_layer, Layer result_layer, char ** options=None, GDALProgressFunc callback=0, void * callback_data=None) -> OGRErr
|
|
|
|
OGRErr OGR_L_Erase(OGRLayerH
|
|
pLayerInput, OGRLayerH pLayerMethod, OGRLayerH pLayerResult, char
|
|
**papszOptions, GDALProgressFunc pfnProgress, void *pProgressArg)
|
|
|
|
Remove areas that are covered by the method layer.
|
|
|
|
The result layer contains features whose geometries represent areas
|
|
that are in the input layer but not in the method layer. The features
|
|
in the result layer have attributes from the input layer. The schema
|
|
of the result layer can be set by the user or, if it is empty, is
|
|
initialized to contain all fields in the input layer.
|
|
|
|
For best performance use the minimum amount of features in the method
|
|
layer and copy it into a memory layer.
|
|
|
|
This method relies on GEOS support. Do not use unless the GEOS support
|
|
is compiled in. The recognized list of options is :
|
|
SKIP_FAILURES=YES/NO. Set it to YES to go on, even when a feature
|
|
could not be inserted or a GEOS call failed.
|
|
|
|
PROMOTE_TO_MULTI=YES/NO. Set it to YES to convert Polygons into
|
|
MultiPolygons, or LineStrings to MultiLineStrings.
|
|
|
|
INPUT_PREFIX=string. Set a prefix for the field names that will be
|
|
created from the fields of the input layer.
|
|
|
|
METHOD_PREFIX=string. Set a prefix for the field names that will be
|
|
created from the fields of the method layer.
|
|
|
|
This function is the same as the C++ method OGRLayer::Erase().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
pLayerInput: the input layer. Should not be NULL.
|
|
|
|
pLayerMethod: the method layer. Should not be NULL.
|
|
|
|
pLayerResult: the layer where the features resulting from the
|
|
operation are inserted. Should not be NULL. See above the note about
|
|
the schema.
|
|
|
|
papszOptions: NULL terminated list of options (may be NULL).
|
|
|
|
pfnProgress: a GDALProgressFunc() compatible callback function for
|
|
reporting progress or NULL.
|
|
|
|
pProgressArg: argument to be passed to pfnProgress. May be NULL.
|
|
|
|
an error code if there was an error or the execution was interrupted,
|
|
OGRERR_NONE otherwise.
|
|
|
|
The first geometry field is always used.
|
|
|
|
OGR 1.10
|
|
"""
|
|
return _ogr.Layer_Erase(self, *args, **kwargs)
|
|
|
|
|
|
def GetStyleTable(self, *args):
|
|
"""
|
|
GetStyleTable(Layer self) -> StyleTable
|
|
|
|
OGRStyleTableH
|
|
OGR_L_GetStyleTable(OGRLayerH hLayer)
|
|
|
|
Get style table.
|
|
"""
|
|
return _ogr.Layer_GetStyleTable(self, *args)
|
|
|
|
|
|
def SetStyleTable(self, *args):
|
|
"""
|
|
SetStyleTable(Layer self, StyleTable table)
|
|
|
|
void
|
|
OGR_L_SetStyleTable(OGRLayerH hLayer, OGRStyleTableH hStyleTable)
|
|
|
|
Set style table.
|
|
"""
|
|
return _ogr.Layer_SetStyleTable(self, *args)
|
|
|
|
|
|
def Reference(self):
|
|
"For backwards compatibility only."
|
|
pass
|
|
|
|
def Dereference(self):
|
|
"For backwards compatibility only."
|
|
pass
|
|
|
|
def __len__(self):
|
|
"""Returns the number of features in the layer"""
|
|
return self.GetFeatureCount()
|
|
|
|
# To avoid __len__ being called when testing boolean value
|
|
# which can have side effects (#4758)
|
|
def __nonzero__(self):
|
|
return True
|
|
|
|
# For Python 3 compat
|
|
__bool__ = __nonzero__
|
|
|
|
def __getitem__(self, value):
|
|
"""Support list and slice -like access to the layer.
|
|
layer[0] would return the first feature on the layer.
|
|
layer[0:4] would return a list of the first four features."""
|
|
if isinstance(value, slice):
|
|
import sys
|
|
output = []
|
|
if value.stop == sys.maxsize:
|
|
#for an unending slice, sys.maxsize is used
|
|
#We need to stop before that or GDAL will write an
|
|
##error to stdout
|
|
stop = len(self) - 1
|
|
else:
|
|
stop = value.stop
|
|
for i in range(value.start, stop, value.step):
|
|
feature = self.GetFeature(i)
|
|
if feature:
|
|
output.append(feature)
|
|
else:
|
|
return output
|
|
return output
|
|
if isinstance(value, int):
|
|
if value > len(self) - 1:
|
|
raise IndexError
|
|
return self.GetFeature(value)
|
|
else:
|
|
raise TypeError("Input %s is not of IntType or SliceType" % type(value))
|
|
|
|
def CreateFields(self, fields):
|
|
"""Create a list of fields on the Layer"""
|
|
for i in fields:
|
|
self.CreateField(i)
|
|
|
|
def __iter__(self):
|
|
self.ResetReading()
|
|
while True:
|
|
feature = self.GetNextFeature()
|
|
if not feature:
|
|
break
|
|
yield feature
|
|
|
|
def schema(self):
|
|
output = []
|
|
defn = self.GetLayerDefn()
|
|
for n in range(defn.GetFieldCount()):
|
|
output.append(defn.GetFieldDefn(n))
|
|
return output
|
|
schema = property(schema)
|
|
|
|
|
|
Layer_swigregister = _ogr.Layer_swigregister
|
|
Layer_swigregister(Layer)
|
|
|
|
class Feature(_object):
|
|
"""Proxy of C++ OGRFeatureShadow class."""
|
|
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, Feature, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, Feature, name)
|
|
__repr__ = _swig_repr
|
|
__swig_destroy__ = _ogr.delete_Feature
|
|
__del__ = lambda self: None
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
"""__init__(OGRFeatureShadow self, FeatureDefn feature_def) -> Feature"""
|
|
this = _ogr.new_Feature(*args, **kwargs)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def GetDefnRef(self, *args):
|
|
"""
|
|
GetDefnRef(Feature self) -> FeatureDefn
|
|
|
|
OGRFeatureDefnH
|
|
OGR_F_GetDefnRef(OGRFeatureH hFeat)
|
|
|
|
Fetch feature definition.
|
|
|
|
This function is the same as the C++ method OGRFeature::GetDefnRef().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hFeat: handle to the feature to get the feature definition from.
|
|
|
|
a handle to the feature definition object on which feature depends.
|
|
|
|
"""
|
|
return _ogr.Feature_GetDefnRef(self, *args)
|
|
|
|
|
|
def SetGeometry(self, *args):
|
|
"""
|
|
SetGeometry(Feature self, Geometry geom) -> OGRErr
|
|
|
|
OGRErr
|
|
OGR_F_SetGeometry(OGRFeatureH hFeat, OGRGeometryH hGeom)
|
|
|
|
Set feature geometry.
|
|
|
|
This function updates the features geometry, and operate exactly as
|
|
SetGeometryDirectly(), except that this function does not assume
|
|
ownership of the passed geometry, but instead makes a copy of it.
|
|
|
|
This function is the same as the C++ OGRFeature::SetGeometry().
|
|
|
|
This method has only an effect on the in-memory feature object. If
|
|
this object comes from a layer and the modifications must be
|
|
serialized back to the datasource, OGR_L_SetFeature() must be used
|
|
afterwards. Or if this is a new feature, OGR_L_CreateFeature() must be
|
|
used afterwards.
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hFeat: handle to the feature on which new geometry is applied to.
|
|
|
|
hGeom: handle to the new geometry to apply to feature.
|
|
|
|
OGRERR_NONE if successful, or OGR_UNSUPPORTED_GEOMETRY_TYPE if the
|
|
geometry type is illegal for the OGRFeatureDefn (checking not yet
|
|
implemented).
|
|
"""
|
|
return _ogr.Feature_SetGeometry(self, *args)
|
|
|
|
|
|
def SetGeometryDirectly(self, *args):
|
|
"""
|
|
SetGeometryDirectly(Feature self, Geometry geom) -> OGRErr
|
|
|
|
OGRErr
|
|
OGR_F_SetGeometryDirectly(OGRFeatureH hFeat, OGRGeometryH hGeom)
|
|
|
|
Set feature geometry.
|
|
|
|
This function updates the features geometry, and operate exactly as
|
|
SetGeometry(), except that this function assumes ownership of the
|
|
passed geometry (even in case of failure of that function).
|
|
|
|
This function is the same as the C++ method
|
|
OGRFeature::SetGeometryDirectly.
|
|
|
|
This method has only an effect on the in-memory feature object. If
|
|
this object comes from a layer and the modifications must be
|
|
serialized back to the datasource, OGR_L_SetFeature() must be used
|
|
afterwards. Or if this is a new feature, OGR_L_CreateFeature() must be
|
|
used afterwards.
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hFeat: handle to the feature on which to apply the geometry.
|
|
|
|
hGeom: handle to the new geometry to apply to feature.
|
|
|
|
OGRERR_NONE if successful, or OGR_UNSUPPORTED_GEOMETRY_TYPE if the
|
|
geometry type is illegal for the OGRFeatureDefn (checking not yet
|
|
implemented).
|
|
"""
|
|
return _ogr.Feature_SetGeometryDirectly(self, *args)
|
|
|
|
|
|
def GetGeometryRef(self, *args):
|
|
"""
|
|
GetGeometryRef(Feature self) -> Geometry
|
|
|
|
OGRGeometryH
|
|
OGR_F_GetGeometryRef(OGRFeatureH hFeat)
|
|
|
|
Fetch a handle to feature geometry.
|
|
|
|
This function is essentially the same as the C++ method
|
|
OGRFeature::GetGeometryRef() (the only difference is that this C
|
|
function honours OGRGetNonLinearGeometriesEnabledFlag())
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hFeat: handle to the feature to get geometry from.
|
|
|
|
a handle to internal feature geometry. This object should not be
|
|
modified.
|
|
"""
|
|
return _ogr.Feature_GetGeometryRef(self, *args)
|
|
|
|
|
|
def SetGeomField(self, *args):
|
|
"""
|
|
SetGeomField(Feature self, int iField, Geometry geom) -> OGRErr
|
|
SetGeomField(Feature self, char const * field_name, Geometry geom) -> OGRErr
|
|
|
|
OGRErr
|
|
OGR_F_SetGeomField(OGRFeatureH hFeat, int iField, OGRGeometryH hGeom)
|
|
|
|
Set feature geometry of a specified geometry field.
|
|
|
|
This function updates the features geometry, and operate exactly as
|
|
SetGeometryDirectly(), except that this function does not assume
|
|
ownership of the passed geometry, but instead makes a copy of it.
|
|
|
|
This function is the same as the C++ OGRFeature::SetGeomField().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hFeat: handle to the feature on which new geometry is applied to.
|
|
|
|
iField: geometry field to set.
|
|
|
|
hGeom: handle to the new geometry to apply to feature.
|
|
|
|
OGRERR_NONE if successful, or OGR_UNSUPPORTED_GEOMETRY_TYPE if the
|
|
geometry type is illegal for the OGRFeatureDefn (checking not yet
|
|
implemented).
|
|
"""
|
|
return _ogr.Feature_SetGeomField(self, *args)
|
|
|
|
|
|
def SetGeomFieldDirectly(self, *args):
|
|
"""
|
|
SetGeomFieldDirectly(Feature self, int iField, Geometry geom) -> OGRErr
|
|
SetGeomFieldDirectly(Feature self, char const * field_name, Geometry geom) -> OGRErr
|
|
|
|
OGRErr
|
|
OGR_F_SetGeomFieldDirectly(OGRFeatureH hFeat, int iField, OGRGeometryH
|
|
hGeom)
|
|
|
|
Set feature geometry of a specified geometry field.
|
|
|
|
This function updates the features geometry, and operate exactly as
|
|
SetGeomField(), except that this function assumes ownership of the
|
|
passed geometry (even in case of failure of that function).
|
|
|
|
This function is the same as the C++ method
|
|
OGRFeature::SetGeomFieldDirectly.
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hFeat: handle to the feature on which to apply the geometry.
|
|
|
|
iField: geometry field to set.
|
|
|
|
hGeom: handle to the new geometry to apply to feature.
|
|
|
|
OGRERR_NONE if successful, or OGRERR_FAILURE if the index is invalid,
|
|
or OGR_UNSUPPORTED_GEOMETRY_TYPE if the geometry type is illegal for
|
|
the OGRFeatureDefn (checking not yet implemented).
|
|
|
|
GDAL 1.11
|
|
"""
|
|
return _ogr.Feature_SetGeomFieldDirectly(self, *args)
|
|
|
|
|
|
def GetGeomFieldRef(self, *args):
|
|
"""
|
|
GetGeomFieldRef(Feature self, int iField) -> Geometry
|
|
GetGeomFieldRef(Feature self, char const * field_name) -> Geometry
|
|
|
|
OGRGeometryH
|
|
OGR_F_GetGeomFieldRef(OGRFeatureH hFeat, int iField)
|
|
|
|
Fetch a handle to feature geometry.
|
|
|
|
This function is the same as the C++ method
|
|
OGRFeature::GetGeomFieldRef().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hFeat: handle to the feature to get geometry from.
|
|
|
|
iField: geometry field to get.
|
|
|
|
a handle to internal feature geometry. This object should not be
|
|
modified.
|
|
|
|
GDAL 1.11
|
|
"""
|
|
return _ogr.Feature_GetGeomFieldRef(self, *args)
|
|
|
|
|
|
def Clone(self, *args):
|
|
"""
|
|
Clone(Feature self) -> Feature
|
|
|
|
OGRFeatureH OGR_F_Clone(OGRFeatureH
|
|
hFeat)
|
|
|
|
Duplicate feature.
|
|
|
|
The newly created feature is owned by the caller, and will have its
|
|
own reference to the OGRFeatureDefn.
|
|
|
|
This function is the same as the C++ method OGRFeature::Clone().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hFeat: handle to the feature to clone.
|
|
|
|
a handle to the new feature, exactly matching this feature.
|
|
"""
|
|
return _ogr.Feature_Clone(self, *args)
|
|
|
|
|
|
def Equal(self, *args):
|
|
"""
|
|
Equal(Feature self, Feature feature) -> bool
|
|
|
|
int OGR_F_Equal(OGRFeatureH hFeat,
|
|
OGRFeatureH hOtherFeat)
|
|
|
|
Test if two features are the same.
|
|
|
|
Two features are considered equal if the share them (handle equality)
|
|
same OGRFeatureDefn, have the same field values, and the same geometry
|
|
(as tested by OGR_G_Equal()) as well as the same feature id.
|
|
|
|
This function is the same as the C++ method OGRFeature::Equal().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hFeat: handle to one of the feature.
|
|
|
|
hOtherFeat: handle to the other feature to test this one against.
|
|
|
|
TRUE if they are equal, otherwise FALSE.
|
|
"""
|
|
return _ogr.Feature_Equal(self, *args)
|
|
|
|
|
|
def GetFieldCount(self, *args):
|
|
"""
|
|
GetFieldCount(Feature self) -> int
|
|
|
|
int
|
|
OGR_F_GetFieldCount(OGRFeatureH hFeat)
|
|
|
|
Fetch number of fields on this feature This will always be the same as
|
|
the field count for the OGRFeatureDefn.
|
|
|
|
This function is the same as the C++ method
|
|
OGRFeature::GetFieldCount().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hFeat: handle to the feature to get the fields count from.
|
|
|
|
count of fields.
|
|
"""
|
|
return _ogr.Feature_GetFieldCount(self, *args)
|
|
|
|
|
|
def GetFieldDefnRef(self, *args):
|
|
"""
|
|
GetFieldDefnRef(Feature self, int id) -> FieldDefn
|
|
GetFieldDefnRef(Feature self, char const * field_name) -> FieldDefn
|
|
|
|
OGRFieldDefnH
|
|
OGR_F_GetFieldDefnRef(OGRFeatureH hFeat, int i)
|
|
|
|
Fetch definition for this field.
|
|
|
|
This function is the same as the C++ method
|
|
OGRFeature::GetFieldDefnRef().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hFeat: handle to the feature on which the field is found.
|
|
|
|
i: the field to fetch, from 0 to GetFieldCount()-1.
|
|
|
|
a handle to the field definition (from the OGRFeatureDefn). This is
|
|
an internal reference, and should not be deleted or modified.
|
|
"""
|
|
return _ogr.Feature_GetFieldDefnRef(self, *args)
|
|
|
|
|
|
def GetGeomFieldCount(self, *args):
|
|
"""
|
|
GetGeomFieldCount(Feature self) -> int
|
|
|
|
int
|
|
OGR_F_GetGeomFieldCount(OGRFeatureH hFeat)
|
|
|
|
Fetch number of geometry fields on this feature This will always be
|
|
the same as the geometry field count for the OGRFeatureDefn.
|
|
|
|
This function is the same as the C++ method
|
|
OGRFeature::GetGeomFieldCount().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hFeat: handle to the feature to get the geometry fields count from.
|
|
|
|
count of geometry fields.
|
|
|
|
GDAL 1.11
|
|
"""
|
|
return _ogr.Feature_GetGeomFieldCount(self, *args)
|
|
|
|
|
|
def GetGeomFieldDefnRef(self, *args):
|
|
"""
|
|
GetGeomFieldDefnRef(Feature self, int id) -> GeomFieldDefn
|
|
GetGeomFieldDefnRef(Feature self, char const * field_name) -> GeomFieldDefn
|
|
|
|
OGRGeomFieldDefnH
|
|
OGR_F_GetGeomFieldDefnRef(OGRFeatureH hFeat, int i)
|
|
|
|
Fetch definition for this geometry field.
|
|
|
|
This function is the same as the C++ method
|
|
OGRFeature::GetGeomFieldDefnRef().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hFeat: handle to the feature on which the field is found.
|
|
|
|
i: the field to fetch, from 0 to GetGeomFieldCount()-1.
|
|
|
|
a handle to the field definition (from the OGRFeatureDefn). This is
|
|
an internal reference, and should not be deleted or modified.
|
|
|
|
GDAL 1.11
|
|
"""
|
|
return _ogr.Feature_GetGeomFieldDefnRef(self, *args)
|
|
|
|
|
|
def GetFieldAsString(self, *args):
|
|
"""
|
|
GetFieldAsString(Feature self, int id) -> char const
|
|
GetFieldAsString(Feature self, char const * field_name) -> char const *
|
|
|
|
const char*
|
|
OGR_F_GetFieldAsString(OGRFeatureH hFeat, int iField)
|
|
|
|
Fetch field value as a string.
|
|
|
|
OFTReal and OFTInteger fields will be translated to string using
|
|
sprintf(), but not necessarily using the established formatting rules.
|
|
Other field types, or errors will result in a return value of zero.
|
|
|
|
This function is the same as the C++ method
|
|
OGRFeature::GetFieldAsString().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hFeat: handle to the feature that owned the field.
|
|
|
|
iField: the field to fetch, from 0 to GetFieldCount()-1.
|
|
|
|
the field value. This string is internal, and should not be modified,
|
|
or freed. Its lifetime may be very brief.
|
|
"""
|
|
return _ogr.Feature_GetFieldAsString(self, *args)
|
|
|
|
|
|
def GetFieldAsInteger(self, *args):
|
|
"""
|
|
GetFieldAsInteger(Feature self, int id) -> int
|
|
GetFieldAsInteger(Feature self, char const * field_name) -> int
|
|
|
|
int
|
|
OGR_F_GetFieldAsInteger(OGRFeatureH hFeat, int iField)
|
|
|
|
Fetch field value as integer.
|
|
|
|
OFTString features will be translated using atoi(). OFTReal fields
|
|
will be cast to integer. Other field types, or errors will result in a
|
|
return value of zero.
|
|
|
|
This function is the same as the C++ method
|
|
OGRFeature::GetFieldAsInteger().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hFeat: handle to the feature that owned the field.
|
|
|
|
iField: the field to fetch, from 0 to GetFieldCount()-1.
|
|
|
|
the field value.
|
|
"""
|
|
return _ogr.Feature_GetFieldAsInteger(self, *args)
|
|
|
|
|
|
def GetFieldAsInteger64(self, *args):
|
|
"""
|
|
GetFieldAsInteger64(Feature self, int id) -> GIntBig
|
|
GetFieldAsInteger64(Feature self, char const * field_name) -> GIntBig
|
|
|
|
GIntBig
|
|
OGR_F_GetFieldAsInteger64(OGRFeatureH hFeat, int iField)
|
|
|
|
Fetch field value as integer 64 bit.
|
|
|
|
OFTInteger are promoted to 64 bit. OFTString features will be
|
|
translated using CPLAtoGIntBig(). OFTReal fields will be cast to
|
|
integer. Other field types, or errors will result in a return value of
|
|
zero.
|
|
|
|
This function is the same as the C++ method
|
|
OGRFeature::GetFieldAsInteger64().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hFeat: handle to the feature that owned the field.
|
|
|
|
iField: the field to fetch, from 0 to GetFieldCount()-1.
|
|
|
|
the field value.
|
|
|
|
GDAL 2.0
|
|
"""
|
|
return _ogr.Feature_GetFieldAsInteger64(self, *args)
|
|
|
|
|
|
def GetFieldAsDouble(self, *args):
|
|
"""
|
|
GetFieldAsDouble(Feature self, int id) -> double
|
|
GetFieldAsDouble(Feature self, char const * field_name) -> double
|
|
|
|
double
|
|
OGR_F_GetFieldAsDouble(OGRFeatureH hFeat, int iField)
|
|
|
|
Fetch field value as a double.
|
|
|
|
OFTString features will be translated using CPLAtof(). OFTInteger
|
|
fields will be cast to double. Other field types, or errors will
|
|
result in a return value of zero.
|
|
|
|
This function is the same as the C++ method
|
|
OGRFeature::GetFieldAsDouble().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hFeat: handle to the feature that owned the field.
|
|
|
|
iField: the field to fetch, from 0 to GetFieldCount()-1.
|
|
|
|
the field value.
|
|
"""
|
|
return _ogr.Feature_GetFieldAsDouble(self, *args)
|
|
|
|
|
|
def GetFieldAsDateTime(self, *args):
|
|
"""
|
|
GetFieldAsDateTime(Feature self, int id)
|
|
GetFieldAsDateTime(Feature self, char const * field_name)
|
|
|
|
int
|
|
OGR_F_GetFieldAsDateTime(OGRFeatureH hFeat, int iField, int *pnYear,
|
|
int *pnMonth, int *pnDay, int *pnHour, int *pnMinute, int *pnSecond,
|
|
int *pnTZFlag)
|
|
|
|
Fetch field value as date and time.
|
|
|
|
Currently this method only works for OFTDate, OFTTime and OFTDateTime
|
|
fields.
|
|
|
|
This function is the same as the C++ method
|
|
OGRFeature::GetFieldAsDateTime().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hFeat: handle to the feature that owned the field.
|
|
|
|
iField: the field to fetch, from 0 to GetFieldCount()-1.
|
|
|
|
pnYear: (including century)
|
|
|
|
pnMonth: (1-12)
|
|
|
|
pnDay: (1-31)
|
|
|
|
pnHour: (0-23)
|
|
|
|
pnMinute: (0-59)
|
|
|
|
pnSecond: (0-59)
|
|
|
|
pnTZFlag: (0=unknown, 1=localtime, 100=GMT, see data model for
|
|
details)
|
|
|
|
TRUE on success or FALSE on failure.
|
|
|
|
See: Use OGR_F_GetFieldAsDateTimeEx() for second with millisecond
|
|
accuracy.
|
|
"""
|
|
return _ogr.Feature_GetFieldAsDateTime(self, *args)
|
|
|
|
|
|
def GetFieldAsIntegerList(self, *args):
|
|
"""
|
|
GetFieldAsIntegerList(Feature self, int id)
|
|
GetFieldAsIntegerList(Feature self, char const * field_name)
|
|
|
|
const int*
|
|
OGR_F_GetFieldAsIntegerList(OGRFeatureH hFeat, int iField, int
|
|
*pnCount)
|
|
|
|
Fetch field value as a list of integers.
|
|
|
|
Currently this function only works for OFTIntegerList fields.
|
|
|
|
This function is the same as the C++ method
|
|
OGRFeature::GetFieldAsIntegerList().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hFeat: handle to the feature that owned the field.
|
|
|
|
iField: the field to fetch, from 0 to GetFieldCount()-1.
|
|
|
|
pnCount: an integer to put the list count (number of integers) into.
|
|
|
|
the field value. This list is internal, and should not be modified, or
|
|
freed. Its lifetime may be very brief. If *pnCount is zero on return
|
|
the returned pointer may be NULL or non-NULL.
|
|
"""
|
|
return _ogr.Feature_GetFieldAsIntegerList(self, *args)
|
|
|
|
|
|
def GetFieldAsInteger64List(self, *args):
|
|
"""
|
|
GetFieldAsInteger64List(Feature self, int id)
|
|
|
|
const GIntBig*
|
|
OGR_F_GetFieldAsInteger64List(OGRFeatureH hFeat, int iField, int
|
|
*pnCount)
|
|
|
|
Fetch field value as a list of 64 bit integers.
|
|
|
|
Currently this function only works for OFTInteger64List fields.
|
|
|
|
This function is the same as the C++ method
|
|
OGRFeature::GetFieldAsInteger64List().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hFeat: handle to the feature that owned the field.
|
|
|
|
iField: the field to fetch, from 0 to GetFieldCount()-1.
|
|
|
|
pnCount: an integer to put the list count (number of integers) into.
|
|
|
|
the field value. This list is internal, and should not be modified, or
|
|
freed. Its lifetime may be very brief. If *pnCount is zero on return
|
|
the returned pointer may be NULL or non-NULL.
|
|
|
|
GDAL 2.0
|
|
"""
|
|
return _ogr.Feature_GetFieldAsInteger64List(self, *args)
|
|
|
|
|
|
def GetFieldAsDoubleList(self, *args):
|
|
"""
|
|
GetFieldAsDoubleList(Feature self, int id)
|
|
GetFieldAsDoubleList(Feature self, char const * field_name)
|
|
|
|
const double*
|
|
OGR_F_GetFieldAsDoubleList(OGRFeatureH hFeat, int iField, int
|
|
*pnCount)
|
|
|
|
Fetch field value as a list of doubles.
|
|
|
|
Currently this function only works for OFTRealList fields.
|
|
|
|
This function is the same as the C++ method
|
|
OGRFeature::GetFieldAsDoubleList().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hFeat: handle to the feature that owned the field.
|
|
|
|
iField: the field to fetch, from 0 to GetFieldCount()-1.
|
|
|
|
pnCount: an integer to put the list count (number of doubles) into.
|
|
|
|
the field value. This list is internal, and should not be modified, or
|
|
freed. Its lifetime may be very brief. If *pnCount is zero on return
|
|
the returned pointer may be NULL or non-NULL.
|
|
"""
|
|
return _ogr.Feature_GetFieldAsDoubleList(self, *args)
|
|
|
|
|
|
def GetFieldAsStringList(self, *args):
|
|
"""
|
|
GetFieldAsStringList(Feature self, int id) -> char **
|
|
|
|
char**
|
|
OGR_F_GetFieldAsStringList(OGRFeatureH hFeat, int iField)
|
|
|
|
Fetch field value as a list of strings.
|
|
|
|
Currently this method only works for OFTStringList fields.
|
|
|
|
The returned list is terminated by a NULL pointer. The number of
|
|
elements can also be calculated using CSLCount().
|
|
|
|
This function is the same as the C++ method
|
|
OGRFeature::GetFieldAsStringList().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hFeat: handle to the feature that owned the field.
|
|
|
|
iField: the field to fetch, from 0 to GetFieldCount()-1.
|
|
|
|
the field value. This list is internal, and should not be modified, or
|
|
freed. Its lifetime may be very brief.
|
|
"""
|
|
return _ogr.Feature_GetFieldAsStringList(self, *args)
|
|
|
|
|
|
def GetFieldAsBinary(self, *args):
|
|
"""
|
|
GetFieldAsBinary(Feature self, int id) -> OGRErr
|
|
GetFieldAsBinary(Feature self, char const * field_name) -> OGRErr
|
|
|
|
GByte*
|
|
OGR_F_GetFieldAsBinary(OGRFeatureH hFeat, int iField, int *pnBytes)
|
|
|
|
Fetch field value as binary.
|
|
|
|
This method only works for OFTBinary and OFTString fields.
|
|
|
|
This function is the same as the C++ method
|
|
OGRFeature::GetFieldAsBinary().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hFeat: handle to the feature that owned the field.
|
|
|
|
iField: the field to fetch, from 0 to GetFieldCount()-1.
|
|
|
|
pnBytes: location to place count of bytes returned.
|
|
|
|
the field value. This list is internal, and should not be modified, or
|
|
freed. Its lifetime may be very brief.
|
|
"""
|
|
return _ogr.Feature_GetFieldAsBinary(self, *args)
|
|
|
|
|
|
def IsFieldSet(self, *args):
|
|
"""
|
|
IsFieldSet(Feature self, int id) -> bool
|
|
IsFieldSet(Feature self, char const * field_name) -> bool
|
|
|
|
int OGR_F_IsFieldSet(OGRFeatureH
|
|
hFeat, int iField)
|
|
|
|
Test if a field has ever been assigned a value or not.
|
|
|
|
This function is the same as the C++ method OGRFeature::IsFieldSet().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hFeat: handle to the feature on which the field is.
|
|
|
|
iField: the field to test.
|
|
|
|
TRUE if the field has been set, otherwise false.
|
|
"""
|
|
return _ogr.Feature_IsFieldSet(self, *args)
|
|
|
|
|
|
def IsFieldNull(self, *args):
|
|
"""
|
|
IsFieldNull(Feature self, int id) -> bool
|
|
IsFieldNull(Feature self, char const * field_name) -> bool
|
|
|
|
int OGR_F_IsFieldNull(OGRFeatureH
|
|
hFeat, int iField)
|
|
|
|
Test if a field is null.
|
|
|
|
This function is the same as the C++ method OGRFeature::IsFieldNull().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hFeat: handle to the feature on which the field is.
|
|
|
|
iField: the field to test.
|
|
|
|
TRUE if the field is null, otherwise false.
|
|
|
|
GDAL 2.2
|
|
"""
|
|
return _ogr.Feature_IsFieldNull(self, *args)
|
|
|
|
|
|
def IsFieldSetAndNotNull(self, *args):
|
|
"""
|
|
IsFieldSetAndNotNull(Feature self, int id) -> bool
|
|
IsFieldSetAndNotNull(Feature self, char const * field_name) -> bool
|
|
|
|
int
|
|
OGR_F_IsFieldSetAndNotNull(OGRFeatureH hFeat, int iField)
|
|
|
|
Test if a field is set and not null.
|
|
|
|
This function is the same as the C++ method
|
|
OGRFeature::IsFieldSetAndNotNull().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hFeat: handle to the feature on which the field is.
|
|
|
|
iField: the field to test.
|
|
|
|
TRUE if the field is set and not null, otherwise false.
|
|
|
|
GDAL 2.2
|
|
"""
|
|
return _ogr.Feature_IsFieldSetAndNotNull(self, *args)
|
|
|
|
|
|
def GetFieldIndex(self, *args):
|
|
"""
|
|
GetFieldIndex(Feature self, char const * field_name) -> int
|
|
|
|
int
|
|
OGR_F_GetFieldIndex(OGRFeatureH hFeat, const char *pszName)
|
|
|
|
Fetch the field index given field name.
|
|
|
|
This is a cover for the OGRFeatureDefn::GetFieldIndex() method.
|
|
|
|
This function is the same as the C++ method
|
|
OGRFeature::GetFieldIndex().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hFeat: handle to the feature on which the field is found.
|
|
|
|
pszName: the name of the field to search for.
|
|
|
|
the field index, or -1 if no matching field is found.
|
|
"""
|
|
return _ogr.Feature_GetFieldIndex(self, *args)
|
|
|
|
|
|
def GetGeomFieldIndex(self, *args):
|
|
"""
|
|
GetGeomFieldIndex(Feature self, char const * field_name) -> int
|
|
|
|
int
|
|
OGR_F_GetGeomFieldIndex(OGRFeatureH hFeat, const char *pszName)
|
|
|
|
Fetch the geometry field index given geometry field name.
|
|
|
|
This is a cover for the OGRFeatureDefn::GetGeomFieldIndex() method.
|
|
|
|
This function is the same as the C++ method
|
|
OGRFeature::GetGeomFieldIndex().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hFeat: handle to the feature on which the geometry field is found.
|
|
|
|
pszName: the name of the geometry field to search for.
|
|
|
|
the geometry field index, or -1 if no matching geometry field is
|
|
found.
|
|
|
|
GDAL 1.11
|
|
"""
|
|
return _ogr.Feature_GetGeomFieldIndex(self, *args)
|
|
|
|
|
|
def GetFID(self, *args):
|
|
"""
|
|
GetFID(Feature self) -> GIntBig
|
|
|
|
GIntBig OGR_F_GetFID(OGRFeatureH
|
|
hFeat)
|
|
|
|
Get feature identifier.
|
|
|
|
This function is the same as the C++ method OGRFeature::GetFID().
|
|
Note: since GDAL 2.0, this method returns a GIntBig (previously a
|
|
long)
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hFeat: handle to the feature from which to get the feature
|
|
identifier.
|
|
|
|
feature id or OGRNullFID if none has been assigned.
|
|
"""
|
|
return _ogr.Feature_GetFID(self, *args)
|
|
|
|
|
|
def SetFID(self, *args):
|
|
"""
|
|
SetFID(Feature self, GIntBig fid) -> OGRErr
|
|
|
|
OGRErr OGR_F_SetFID(OGRFeatureH hFeat,
|
|
GIntBig nFID)
|
|
|
|
Set the feature identifier.
|
|
|
|
For specific types of features this operation may fail on illegal
|
|
features ids. Generally it always succeeds. Feature ids should be
|
|
greater than or equal to zero, with the exception of OGRNullFID (-1)
|
|
indicating that the feature id is unknown.
|
|
|
|
This function is the same as the C++ method OGRFeature::SetFID().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hFeat: handle to the feature to set the feature id to.
|
|
|
|
nFID: the new feature identifier value to assign.
|
|
|
|
On success OGRERR_NONE, or on failure some other value.
|
|
"""
|
|
return _ogr.Feature_SetFID(self, *args)
|
|
|
|
|
|
def DumpReadable(self, *args):
|
|
"""
|
|
DumpReadable(Feature self)
|
|
|
|
void
|
|
OGR_F_DumpReadable(OGRFeatureH hFeat, FILE *fpOut)
|
|
|
|
Dump this feature in a human readable form.
|
|
|
|
This dumps the attributes, and geometry; however, it doesn't
|
|
definition information (other than field types and names), nor does it
|
|
report the geometry spatial reference system.
|
|
|
|
This function is the same as the C++ method
|
|
OGRFeature::DumpReadable().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hFeat: handle to the feature to dump.
|
|
|
|
fpOut: the stream to write to, such as strout.
|
|
"""
|
|
return _ogr.Feature_DumpReadable(self, *args)
|
|
|
|
|
|
def UnsetField(self, *args):
|
|
"""
|
|
UnsetField(Feature self, int id)
|
|
UnsetField(Feature self, char const * field_name)
|
|
|
|
void OGR_F_UnsetField(OGRFeatureH
|
|
hFeat, int iField)
|
|
|
|
Clear a field, marking it as unset.
|
|
|
|
This function is the same as the C++ method OGRFeature::UnsetField().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hFeat: handle to the feature on which the field is.
|
|
|
|
iField: the field to unset.
|
|
"""
|
|
return _ogr.Feature_UnsetField(self, *args)
|
|
|
|
|
|
def SetFieldNull(self, *args):
|
|
"""
|
|
SetFieldNull(Feature self, int id)
|
|
SetFieldNull(Feature self, char const * field_name)
|
|
|
|
void
|
|
OGR_F_SetFieldNull(OGRFeatureH hFeat, int iField)
|
|
|
|
Clear a field, marking it as null.
|
|
|
|
This function is the same as the C++ method
|
|
OGRFeature::SetFieldNull().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hFeat: handle to the feature on which the field is.
|
|
|
|
iField: the field to set to null.
|
|
|
|
GDAL 2.2
|
|
"""
|
|
return _ogr.Feature_SetFieldNull(self, *args)
|
|
|
|
|
|
def SetFieldInteger64(self, *args):
|
|
"""
|
|
SetFieldInteger64(Feature self, int id, GIntBig value)
|
|
|
|
void
|
|
OGR_F_SetFieldInteger64(OGRFeatureH hFeat, int iField, GIntBig nValue)
|
|
|
|
Set field to 64 bit integer value.
|
|
|
|
OFTInteger, OFTInteger64 and OFTReal fields will be set directly.
|
|
OFTString fields will be assigned a string representation of the
|
|
value, but not necessarily taking into account formatting constraints
|
|
on this field. Other field types may be unaffected.
|
|
|
|
This function is the same as the C++ method OGRFeature::SetField().
|
|
|
|
This method has only an effect on the in-memory feature object. If
|
|
this object comes from a layer and the modifications must be
|
|
serialized back to the datasource, OGR_L_SetFeature() must be used
|
|
afterwards. Or if this is a new feature, OGR_L_CreateFeature() must be
|
|
used afterwards.
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hFeat: handle to the feature that owned the field.
|
|
|
|
iField: the field to fetch, from 0 to GetFieldCount()-1.
|
|
|
|
nValue: the value to assign.
|
|
|
|
GDAL 2.0
|
|
"""
|
|
return _ogr.Feature_SetFieldInteger64(self, *args)
|
|
|
|
|
|
def SetField(self, *args):
|
|
"""
|
|
SetField(Feature self, int id, char const * value)
|
|
SetField(Feature self, char const * field_name, char const * value)
|
|
SetField(Feature self, int id, double value)
|
|
SetField(Feature self, char const * field_name, double value)
|
|
SetField(Feature self, int id, int year, int month, int day, int hour, int minute, float second, int tzflag)
|
|
SetField(Feature self, char const * field_name, int year, int month, int day, int hour, int minute, float second, int tzflag)
|
|
"""
|
|
return _ogr.Feature_SetField(self, *args)
|
|
|
|
|
|
def SetFieldIntegerList(self, *args):
|
|
"""
|
|
SetFieldIntegerList(Feature self, int id, int nList)
|
|
|
|
void
|
|
OGR_F_SetFieldIntegerList(OGRFeatureH hFeat, int iField, int nCount,
|
|
const int *panValues)
|
|
|
|
Set field to list of integers value.
|
|
|
|
This function currently on has an effect of OFTIntegerList,
|
|
OFTInteger64List and OFTRealList fields.
|
|
|
|
This function is the same as the C++ method OGRFeature::SetField().
|
|
|
|
This method has only an effect on the in-memory feature object. If
|
|
this object comes from a layer and the modifications must be
|
|
serialized back to the datasource, OGR_L_SetFeature() must be used
|
|
afterwards. Or if this is a new feature, OGR_L_CreateFeature() must be
|
|
used afterwards.
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hFeat: handle to the feature that owned the field.
|
|
|
|
iField: the field to set, from 0 to GetFieldCount()-1.
|
|
|
|
nCount: the number of values in the list being assigned.
|
|
|
|
panValues: the values to assign.
|
|
"""
|
|
return _ogr.Feature_SetFieldIntegerList(self, *args)
|
|
|
|
|
|
def SetFieldInteger64List(self, *args):
|
|
"""
|
|
SetFieldInteger64List(Feature self, int id, int nList)
|
|
|
|
void
|
|
OGR_F_SetFieldInteger64List(OGRFeatureH hFeat, int iField, int nCount,
|
|
const GIntBig *panValues)
|
|
|
|
Set field to list of 64 bit integers value.
|
|
|
|
This function currently on has an effect of OFTIntegerList,
|
|
OFTInteger64List and OFTRealList fields.
|
|
|
|
This function is the same as the C++ method OGRFeature::SetField().
|
|
|
|
This method has only an effect on the in-memory feature object. If
|
|
this object comes from a layer and the modifications must be
|
|
serialized back to the datasource, OGR_L_SetFeature() must be used
|
|
afterwards. Or if this is a new feature, OGR_L_CreateFeature() must be
|
|
used afterwards.
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hFeat: handle to the feature that owned the field.
|
|
|
|
iField: the field to set, from 0 to GetFieldCount()-1.
|
|
|
|
nCount: the number of values in the list being assigned.
|
|
|
|
panValues: the values to assign.
|
|
|
|
GDAL 2.0
|
|
"""
|
|
return _ogr.Feature_SetFieldInteger64List(self, *args)
|
|
|
|
|
|
def SetFieldDoubleList(self, *args):
|
|
"""
|
|
SetFieldDoubleList(Feature self, int id, int nList)
|
|
|
|
void
|
|
OGR_F_SetFieldDoubleList(OGRFeatureH hFeat, int iField, int nCount,
|
|
const double *padfValues)
|
|
|
|
Set field to list of doubles value.
|
|
|
|
This function currently on has an effect of OFTIntegerList,
|
|
OFTInteger64List, OFTRealList fields.
|
|
|
|
This function is the same as the C++ method OGRFeature::SetField().
|
|
|
|
This method has only an effect on the in-memory feature object. If
|
|
this object comes from a layer and the modifications must be
|
|
serialized back to the datasource, OGR_L_SetFeature() must be used
|
|
afterwards. Or if this is a new feature, OGR_L_CreateFeature() must be
|
|
used afterwards.
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hFeat: handle to the feature that owned the field.
|
|
|
|
iField: the field to set, from 0 to GetFieldCount()-1.
|
|
|
|
nCount: the number of values in the list being assigned.
|
|
|
|
padfValues: the values to assign.
|
|
"""
|
|
return _ogr.Feature_SetFieldDoubleList(self, *args)
|
|
|
|
|
|
def SetFieldStringList(self, *args):
|
|
"""
|
|
SetFieldStringList(Feature self, int id, char ** pList)
|
|
|
|
void
|
|
OGR_F_SetFieldStringList(OGRFeatureH hFeat, int iField, CSLConstList
|
|
papszValues)
|
|
|
|
Set field to list of strings value.
|
|
|
|
This function currently on has an effect of OFTStringList fields.
|
|
|
|
This function is the same as the C++ method OGRFeature::SetField().
|
|
|
|
This method has only an effect on the in-memory feature object. If
|
|
this object comes from a layer and the modifications must be
|
|
serialized back to the datasource, OGR_L_SetFeature() must be used
|
|
afterwards. Or if this is a new feature, OGR_L_CreateFeature() must be
|
|
used afterwards.
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hFeat: handle to the feature that owned the field.
|
|
|
|
iField: the field to set, from 0 to GetFieldCount()-1.
|
|
|
|
papszValues: the values to assign. List of NUL-terminated string,
|
|
ending with a NULL pointer.
|
|
"""
|
|
return _ogr.Feature_SetFieldStringList(self, *args)
|
|
|
|
|
|
def SetFieldBinaryFromHexString(self, *args):
|
|
"""
|
|
SetFieldBinaryFromHexString(Feature self, int id, char const * pszValue)
|
|
SetFieldBinaryFromHexString(Feature self, char const * field_name, char const * pszValue)
|
|
"""
|
|
return _ogr.Feature_SetFieldBinaryFromHexString(self, *args)
|
|
|
|
|
|
def SetFrom(self, *args, **kwargs):
|
|
"""
|
|
SetFrom(Feature self, Feature other, int forgiving=1) -> OGRErr
|
|
|
|
OGRErr OGR_F_SetFrom(OGRFeatureH
|
|
hFeat, OGRFeatureH hOtherFeat, int bForgiving)
|
|
|
|
Set one feature from another.
|
|
|
|
Overwrite the contents of this feature from the geometry and
|
|
attributes of another. The hOtherFeature does not need to have the
|
|
same OGRFeatureDefn. Field values are copied by corresponding field
|
|
names. Field types do not have to exactly match. OGR_F_SetField*()
|
|
function conversion rules will be applied as needed.
|
|
|
|
This function is the same as the C++ method OGRFeature::SetFrom().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hFeat: handle to the feature to set to.
|
|
|
|
hOtherFeat: handle to the feature from which geometry, and field
|
|
values will be copied.
|
|
|
|
bForgiving: TRUE if the operation should continue despite lacking
|
|
output fields matching some of the source fields.
|
|
|
|
OGRERR_NONE if the operation succeeds, even if some values are not
|
|
transferred, otherwise an error code.
|
|
"""
|
|
return _ogr.Feature_SetFrom(self, *args, **kwargs)
|
|
|
|
|
|
def SetFromWithMap(self, *args):
|
|
"""
|
|
SetFromWithMap(Feature self, Feature other, int forgiving, int nList) -> OGRErr
|
|
|
|
OGRErr
|
|
OGR_F_SetFromWithMap(OGRFeatureH hFeat, OGRFeatureH hOtherFeat, int
|
|
bForgiving, const int *panMap)
|
|
|
|
Set one feature from another.
|
|
|
|
Overwrite the contents of this feature from the geometry and
|
|
attributes of another. The hOtherFeature does not need to have the
|
|
same OGRFeatureDefn. Field values are copied according to the provided
|
|
indices map. Field types do not have to exactly match.
|
|
OGR_F_SetField*() function conversion rules will be applied as needed.
|
|
This is more efficient than OGR_F_SetFrom() in that this doesn't
|
|
lookup the fields by their names. Particularly useful when the field
|
|
names don't match.
|
|
|
|
This function is the same as the C++ method OGRFeature::SetFrom().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hFeat: handle to the feature to set to.
|
|
|
|
hOtherFeat: handle to the feature from which geometry, and field
|
|
values will be copied.
|
|
|
|
panMap: Array of the indices of the destination feature's fields
|
|
stored at the corresponding index of the source feature's fields. A
|
|
value of -1 should be used to ignore the source's field. The array
|
|
should not be NULL and be as long as the number of fields in the
|
|
source feature.
|
|
|
|
bForgiving: TRUE if the operation should continue despite lacking
|
|
output fields matching some of the source fields.
|
|
|
|
OGRERR_NONE if the operation succeeds, even if some values are not
|
|
transferred, otherwise an error code.
|
|
"""
|
|
return _ogr.Feature_SetFromWithMap(self, *args)
|
|
|
|
|
|
def GetStyleString(self, *args):
|
|
"""
|
|
GetStyleString(Feature self) -> char const *
|
|
|
|
const char*
|
|
OGR_F_GetStyleString(OGRFeatureH hFeat)
|
|
|
|
Fetch style string for this feature.
|
|
|
|
Set the OGR Feature Style Specification for details on the format of
|
|
this string, and ogr_featurestyle.h for services available to parse
|
|
it.
|
|
|
|
This function is the same as the C++ method
|
|
OGRFeature::GetStyleString().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hFeat: handle to the feature to get the style from.
|
|
|
|
a reference to a representation in string format, or NULL if there
|
|
isn't one.
|
|
"""
|
|
return _ogr.Feature_GetStyleString(self, *args)
|
|
|
|
|
|
def SetStyleString(self, *args):
|
|
"""
|
|
SetStyleString(Feature self, char const * the_string)
|
|
|
|
void
|
|
OGR_F_SetStyleString(OGRFeatureH hFeat, const char *pszStyle)
|
|
|
|
Set feature style string.
|
|
|
|
This method operate exactly as OGR_F_SetStyleStringDirectly() except
|
|
that it does not assume ownership of the passed string, but instead
|
|
makes a copy of it.
|
|
|
|
This function is the same as the C++ method
|
|
OGRFeature::SetStyleString().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hFeat: handle to the feature to set style to.
|
|
|
|
pszStyle: the style string to apply to this feature, cannot be NULL.
|
|
|
|
"""
|
|
return _ogr.Feature_SetStyleString(self, *args)
|
|
|
|
|
|
def GetFieldType(self, *args):
|
|
"""
|
|
GetFieldType(Feature self, int id) -> OGRFieldType
|
|
GetFieldType(Feature self, char const * field_name) -> OGRFieldType
|
|
"""
|
|
return _ogr.Feature_GetFieldType(self, *args)
|
|
|
|
|
|
def Validate(self, *args):
|
|
"""
|
|
Validate(Feature self, int flags, int bEmitError=True) -> int
|
|
|
|
int OGR_F_Validate(OGRFeatureH
|
|
hFeat, int nValidateFlags, int bEmitError)
|
|
|
|
Validate that a feature meets constraints of its schema.
|
|
|
|
The scope of test is specified with the nValidateFlags parameter.
|
|
|
|
Regarding OGR_F_VAL_WIDTH, the test is done assuming the string width
|
|
must be interpreted as the number of UTF-8 characters. Some drivers
|
|
might interpret the width as the number of bytes instead. So this test
|
|
is rather conservative (if it fails, then it will fail for all
|
|
interpretations).
|
|
|
|
This function is the same as the C++ method OGRFeature::Validate().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hFeat: handle to the feature to validate.
|
|
|
|
nValidateFlags: OGR_F_VAL_ALL or combination of OGR_F_VAL_NULL,
|
|
OGR_F_VAL_GEOM_TYPE, OGR_F_VAL_WIDTH and
|
|
OGR_F_VAL_ALLOW_NULL_WHEN_DEFAULT with '|' operator
|
|
|
|
bEmitError: TRUE if a CPLError() must be emitted when a check fails
|
|
|
|
TRUE if all enabled validation tests pass.
|
|
|
|
GDAL 2.0
|
|
"""
|
|
return _ogr.Feature_Validate(self, *args)
|
|
|
|
|
|
def FillUnsetWithDefault(self, *args):
|
|
"""
|
|
FillUnsetWithDefault(Feature self, int bNotNullableOnly=False, char ** options=None)
|
|
|
|
void
|
|
OGR_F_FillUnsetWithDefault(OGRFeatureH hFeat, int bNotNullableOnly,
|
|
char **papszOptions)
|
|
|
|
Fill unset fields with default values that might be defined.
|
|
|
|
This function is the same as the C++ method
|
|
OGRFeature::FillUnsetWithDefault().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hFeat: handle to the feature.
|
|
|
|
bNotNullableOnly: if we should fill only unset fields with a not-null
|
|
constraint.
|
|
|
|
papszOptions: unused currently. Must be set to NULL.
|
|
|
|
GDAL 2.0
|
|
"""
|
|
return _ogr.Feature_FillUnsetWithDefault(self, *args)
|
|
|
|
|
|
def GetNativeData(self, *args):
|
|
"""
|
|
GetNativeData(Feature self) -> char const *
|
|
|
|
const char*
|
|
OGR_F_GetNativeData(OGRFeatureH hFeat)
|
|
|
|
Returns the native data for the feature.
|
|
|
|
The native data is the representation in a "natural" form that comes
|
|
from the driver that created this feature, or that is aimed at an
|
|
output driver. The native data may be in different format, which is
|
|
indicated by OGR_F_GetNativeMediaType().
|
|
|
|
Note that most drivers do not support storing the native data in the
|
|
feature object, and if they do, generally the NATIVE_DATA open option
|
|
must be passed at dataset opening.
|
|
|
|
The "native data" does not imply it is something more performant or
|
|
powerful than what can be obtained with the rest of the API, but it
|
|
may be useful in round-tripping scenarios where some characteristics
|
|
of the underlying format are not captured otherwise by the OGR
|
|
abstraction.
|
|
|
|
This function is the same as the C++ method
|
|
OGRFeature::GetNativeData().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hFeat: handle to the feature.
|
|
|
|
a string with the native data, or NULL if there is none.
|
|
|
|
GDAL 2.1
|
|
|
|
See:
|
|
https://trac.osgeo.org/gdal/wiki/rfc60_improved_roundtripping_in_ogr
|
|
|
|
"""
|
|
return _ogr.Feature_GetNativeData(self, *args)
|
|
|
|
|
|
def GetNativeMediaType(self, *args):
|
|
"""
|
|
GetNativeMediaType(Feature self) -> char const *
|
|
|
|
const char*
|
|
OGR_F_GetNativeMediaType(OGRFeatureH hFeat)
|
|
|
|
Returns the native media type for the feature.
|
|
|
|
The native media type is the identifier for the format of the native
|
|
data. It follows the IANA RFC 2045
|
|
(seehttps://en.wikipedia.org/wiki/Media_type), e.g.
|
|
"application/vnd.geo+json" for JSon.
|
|
|
|
This function is the same as the C function
|
|
OGR_F_GetNativeMediaType().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hFeat: handle to the feature.
|
|
|
|
a string with the native media type, or NULL if there is none.
|
|
|
|
GDAL 2.1
|
|
|
|
See:
|
|
https://trac.osgeo.org/gdal/wiki/rfc60_improved_roundtripping_in_ogr
|
|
|
|
"""
|
|
return _ogr.Feature_GetNativeMediaType(self, *args)
|
|
|
|
|
|
def SetNativeData(self, *args):
|
|
"""
|
|
SetNativeData(Feature self, char const * nativeData)
|
|
|
|
void
|
|
OGR_F_SetNativeData(OGRFeatureH hFeat, const char *pszNativeData)
|
|
|
|
Sets the native data for the feature.
|
|
|
|
The native data is the representation in a "natural" form that comes
|
|
from the driver that created this feature, or that is aimed at an
|
|
output driver. The native data may be in different format, which is
|
|
indicated by OGR_F_GetNativeMediaType().
|
|
|
|
This function is the same as the C++ method
|
|
OGRFeature::SetNativeData().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hFeat: handle to the feature.
|
|
|
|
pszNativeData: a string with the native data, or NULL if there is
|
|
none.
|
|
|
|
GDAL 2.1
|
|
|
|
See:
|
|
https://trac.osgeo.org/gdal/wiki/rfc60_improved_roundtripping_in_ogr
|
|
|
|
"""
|
|
return _ogr.Feature_SetNativeData(self, *args)
|
|
|
|
|
|
def SetNativeMediaType(self, *args):
|
|
"""
|
|
SetNativeMediaType(Feature self, char const * nativeMediaType)
|
|
|
|
void
|
|
OGR_F_SetNativeMediaType(OGRFeatureH hFeat, const char
|
|
*pszNativeMediaType)
|
|
|
|
Sets the native media type for the feature.
|
|
|
|
The native media type is the identifier for the format of the native
|
|
data. It follows the IANA RFC 2045
|
|
(seehttps://en.wikipedia.org/wiki/Media_type), e.g.
|
|
"application/vnd.geo+json" for JSon.
|
|
|
|
This function is the same as the C++ method
|
|
OGRFeature::SetNativeMediaType().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hFeat: handle to the feature.
|
|
|
|
pszNativeMediaType: a string with the native media type, or NULL if
|
|
there is none.
|
|
|
|
GDAL 2.1
|
|
|
|
See:
|
|
https://trac.osgeo.org/gdal/wiki/rfc60_improved_roundtripping_in_ogr
|
|
|
|
"""
|
|
return _ogr.Feature_SetNativeMediaType(self, *args)
|
|
|
|
|
|
def SetFieldString(self, *args):
|
|
"""
|
|
SetFieldString(Feature self, int id, char const * value)
|
|
|
|
void
|
|
OGR_F_SetFieldString(OGRFeatureH hFeat, int iField, const char
|
|
*pszValue)
|
|
|
|
Set field to string value.
|
|
|
|
OFTInteger fields will be set based on an atoi() conversion of the
|
|
string. OFTInteger64 fields will be set based on an CPLAtoGIntBig()
|
|
conversion of the string. OFTReal fields will be set based on an
|
|
CPLAtof() conversion of the string. Other field types may be
|
|
unaffected.
|
|
|
|
This function is the same as the C++ method OGRFeature::SetField().
|
|
|
|
This method has only an effect on the in-memory feature object. If
|
|
this object comes from a layer and the modifications must be
|
|
serialized back to the datasource, OGR_L_SetFeature() must be used
|
|
afterwards. Or if this is a new feature, OGR_L_CreateFeature() must be
|
|
used afterwards.
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hFeat: handle to the feature that owned the field.
|
|
|
|
iField: the field to fetch, from 0 to GetFieldCount()-1.
|
|
|
|
pszValue: the value to assign.
|
|
"""
|
|
return _ogr.Feature_SetFieldString(self, *args)
|
|
|
|
|
|
def Reference(self):
|
|
pass
|
|
|
|
def Dereference(self):
|
|
pass
|
|
|
|
def Destroy(self):
|
|
"Once called, self has effectively been destroyed. Do not access. For backwards compatibility only"
|
|
_ogr.delete_Feature(self)
|
|
self.thisown = 0
|
|
|
|
def __cmp__(self, other):
|
|
"""Compares a feature to another for equality"""
|
|
return self.Equal(other)
|
|
|
|
def __copy__(self):
|
|
return self.Clone()
|
|
|
|
def _getfieldindex(self, fieldname):
|
|
case_insensitive_idx = -1
|
|
fdefn = _ogr.Feature_GetDefnRef(self)
|
|
for i in range(fdefn.GetFieldCount()):
|
|
name = fdefn.GetFieldDefn(i).GetName()
|
|
if name == fieldname:
|
|
return i
|
|
elif case_insensitive_idx < 0 and name.lower() == fieldname.lower():
|
|
case_insensitive_idx = i
|
|
return case_insensitive_idx
|
|
|
|
# This makes it possible to fetch fields in the form "feature.area".
|
|
# This has some risk of name collisions.
|
|
def __getattr__(self, key):
|
|
"""Returns the values of fields by the given name"""
|
|
if key == 'this':
|
|
return self.__dict__[key]
|
|
|
|
idx = self._getfieldindex(key)
|
|
if idx < 0:
|
|
idx = self.GetGeomFieldIndex(key)
|
|
if idx < 0:
|
|
raise AttributeError(key)
|
|
else:
|
|
return self.GetGeomFieldRef(idx)
|
|
else:
|
|
return self.GetField(idx)
|
|
|
|
# This makes it possible to set fields in the form "feature.area".
|
|
# This has some risk of name collisions.
|
|
def __setattr__(self, key, value):
|
|
"""Set the values of fields by the given name"""
|
|
if key == 'this' or key == 'thisown':
|
|
self.__dict__[key] = value
|
|
else:
|
|
idx = self._getfieldindex(key)
|
|
if idx != -1:
|
|
self.SetField2(idx, value)
|
|
else:
|
|
idx = self.GetGeomFieldIndex(key)
|
|
if idx != -1:
|
|
self.SetGeomField(idx, value)
|
|
else:
|
|
self.__dict__[key] = value
|
|
|
|
# This makes it possible to fetch fields in the form "feature['area']".
|
|
def __getitem__(self, key):
|
|
"""Returns the values of fields by the given name / field_index"""
|
|
if isinstance(key, str):
|
|
fld_index = self._getfieldindex(key)
|
|
else:
|
|
fld_index = key
|
|
if key == self.GetFieldCount():
|
|
raise IndexError
|
|
if fld_index < 0:
|
|
if isinstance(key, str):
|
|
fld_index = self.GetGeomFieldIndex(key)
|
|
if fld_index < 0:
|
|
raise KeyError("Illegal field requested in GetField()")
|
|
else:
|
|
return self.GetGeomFieldRef(fld_index)
|
|
else:
|
|
return self.GetField(fld_index)
|
|
|
|
# This makes it possible to set fields in the form "feature['area'] = 123".
|
|
def __setitem__(self, key, value):
|
|
"""Returns the value of a field by field name / index"""
|
|
if isinstance(key, str):
|
|
fld_index = self._getfieldindex(key)
|
|
else:
|
|
fld_index = key
|
|
if key == self.GetFieldCount():
|
|
raise IndexError
|
|
if fld_index < 0:
|
|
if isinstance(key, str):
|
|
fld_index = self.GetGeomFieldIndex(key)
|
|
if fld_index < 0:
|
|
raise KeyError("Illegal field requested in SetField()")
|
|
else:
|
|
return self.SetGeomField(fld_index, value)
|
|
else:
|
|
return self.SetField2(fld_index, value)
|
|
|
|
def GetField(self, fld_index):
|
|
if isinstance(fld_index, str):
|
|
fld_index = self._getfieldindex(fld_index)
|
|
if (fld_index < 0) or (fld_index > self.GetFieldCount()):
|
|
raise KeyError("Illegal field requested in GetField()")
|
|
if not (self.IsFieldSet(fld_index)) or self.IsFieldNull(fld_index):
|
|
return None
|
|
fld_type = self.GetFieldType(fld_index)
|
|
if fld_type == OFTInteger:
|
|
return self.GetFieldAsInteger(fld_index)
|
|
if fld_type == OFTInteger64:
|
|
return self.GetFieldAsInteger64(fld_index)
|
|
if fld_type == OFTReal:
|
|
return self.GetFieldAsDouble(fld_index)
|
|
if fld_type == OFTStringList:
|
|
return self.GetFieldAsStringList(fld_index)
|
|
if fld_type == OFTIntegerList:
|
|
return self.GetFieldAsIntegerList(fld_index)
|
|
if fld_type == OFTInteger64List:
|
|
return self.GetFieldAsInteger64List(fld_index)
|
|
if fld_type == OFTRealList:
|
|
return self.GetFieldAsDoubleList(fld_index)
|
|
## if fld_type == OFTDateTime or fld_type == OFTDate or fld_type == OFTTime:
|
|
# return self.GetFieldAsDate(fld_index)
|
|
# default to returning as a string. Should we add more types?
|
|
try:
|
|
return self.GetFieldAsString(fld_index)
|
|
except:
|
|
# For Python3 on non-UTF8 strings
|
|
return self.GetFieldAsBinary(fld_index)
|
|
|
|
# With several override, SWIG cannot dispatch automatically unicode strings
|
|
# to the right implementation, so we have to do it at hand
|
|
def SetField(self, *args):
|
|
"""
|
|
SetField(self, int id, char value)
|
|
SetField(self, char name, char value)
|
|
SetField(self, int id, int value)
|
|
SetField(self, char name, int value)
|
|
SetField(self, int id, double value)
|
|
SetField(self, char name, double value)
|
|
SetField(self, int id, int year, int month, int day, int hour, int minute,
|
|
int second, int tzflag)
|
|
SetField(self, char name, int year, int month, int day, int hour,
|
|
int minute, int second, int tzflag)
|
|
"""
|
|
|
|
if len(args) == 2 and args[1] is None:
|
|
return _ogr.Feature_SetFieldNull(self, args[0])
|
|
|
|
if len(args) == 2 and (type(args[1]) == type(1) or type(args[1]) == type(12345678901234)):
|
|
fld_index = args[0]
|
|
if isinstance(fld_index, str):
|
|
fld_index = self._getfieldindex(fld_index)
|
|
return _ogr.Feature_SetFieldInteger64(self, fld_index, args[1])
|
|
|
|
|
|
if len(args) == 2 and isinstance(args[1], str):
|
|
fld_index = args[0]
|
|
if isinstance(fld_index, str):
|
|
fld_index = self._getfieldindex(fld_index)
|
|
return _ogr.Feature_SetFieldString(self, fld_index, args[1])
|
|
|
|
return _ogr.Feature_SetField(self, *args)
|
|
|
|
def SetField2(self, fld_index, value):
|
|
if isinstance(fld_index, str):
|
|
fld_index = self._getfieldindex(fld_index)
|
|
if (fld_index < 0) or (fld_index > self.GetFieldCount()):
|
|
raise KeyError("Illegal field requested in SetField2()")
|
|
|
|
if value is None:
|
|
self.SetFieldNull(fld_index)
|
|
return
|
|
|
|
if isinstance(value, list):
|
|
if not value:
|
|
self.SetFieldNull(fld_index)
|
|
return
|
|
if isinstance(value[0], type(1)) or isinstance(value[0], type(12345678901234)):
|
|
self.SetFieldInteger64List(fld_index, value)
|
|
return
|
|
elif isinstance(value[0], float):
|
|
self.SetFieldDoubleList(fld_index, value)
|
|
return
|
|
elif isinstance(value[0], str):
|
|
self.SetFieldStringList(fld_index, value)
|
|
return
|
|
else:
|
|
raise TypeError('Unsupported type of list in SetField2(). Type of element is %s' % str(type(value[0])))
|
|
|
|
try:
|
|
self.SetField(fld_index, value)
|
|
except:
|
|
self.SetField(fld_index, str(value))
|
|
return
|
|
|
|
def keys(self):
|
|
names = []
|
|
for i in range(self.GetFieldCount()):
|
|
fieldname = self.GetFieldDefnRef(i).GetName()
|
|
names.append(fieldname)
|
|
return names
|
|
|
|
def items(self):
|
|
keys = self.keys()
|
|
output = {}
|
|
for key in keys:
|
|
output[key] = self.GetField(key)
|
|
return output
|
|
def geometry(self):
|
|
return self.GetGeometryRef()
|
|
|
|
def ExportToJson(self, as_object=False, options=None):
|
|
"""Exports a GeoJSON object which represents the Feature. The
|
|
as_object parameter determines whether the returned value
|
|
should be a Python object instead of a string. Defaults to False.
|
|
The options parameter is passed to Geometry.ExportToJson()"""
|
|
|
|
try:
|
|
import simplejson
|
|
except ImportError:
|
|
try:
|
|
import json as simplejson
|
|
except ImportError:
|
|
raise ImportError("Unable to import simplejson or json, needed for ExportToJson.")
|
|
|
|
geom = self.GetGeometryRef()
|
|
if geom is not None:
|
|
if options is None:
|
|
options = []
|
|
geom_json_string = geom.ExportToJson(options=options)
|
|
geom_json_object = simplejson.loads(geom_json_string)
|
|
else:
|
|
geom_json_object = None
|
|
|
|
output = {'type':'Feature',
|
|
'geometry': geom_json_object,
|
|
'properties': {}
|
|
}
|
|
|
|
fid = self.GetFID()
|
|
if fid != NullFID:
|
|
output['id'] = fid
|
|
|
|
for key in self.keys():
|
|
fld_defn = self.GetFieldDefnRef(self.GetFieldIndex(key))
|
|
if fld_defn.GetType() == _ogr.OFTInteger and fld_defn.GetSubType() == _ogr.OFSTBoolean:
|
|
output['properties'][key] = bool(self.GetField(key))
|
|
else:
|
|
output['properties'][key] = self.GetField(key)
|
|
|
|
if not as_object:
|
|
output = simplejson.dumps(output)
|
|
|
|
return output
|
|
|
|
|
|
|
|
Feature_swigregister = _ogr.Feature_swigregister
|
|
Feature_swigregister(Feature)
|
|
|
|
class FeatureDefn(_object):
|
|
"""Proxy of C++ OGRFeatureDefnShadow class."""
|
|
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, FeatureDefn, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, FeatureDefn, name)
|
|
__repr__ = _swig_repr
|
|
__swig_destroy__ = _ogr.delete_FeatureDefn
|
|
__del__ = lambda self: None
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
"""__init__(OGRFeatureDefnShadow self, char const * name_null_ok=None) -> FeatureDefn"""
|
|
this = _ogr.new_FeatureDefn(*args, **kwargs)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def GetName(self, *args):
|
|
"""
|
|
GetName(FeatureDefn self) -> char const *
|
|
|
|
const char*
|
|
OGR_FD_GetName(OGRFeatureDefnH hDefn)
|
|
|
|
Get name of the OGRFeatureDefn passed as an argument.
|
|
|
|
This function is the same as the C++ method OGRFeatureDefn::GetName().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hDefn: handle to the feature definition to get the name from.
|
|
|
|
the name. This name is internal and should not be modified, or freed.
|
|
|
|
"""
|
|
return _ogr.FeatureDefn_GetName(self, *args)
|
|
|
|
|
|
def GetFieldCount(self, *args):
|
|
"""
|
|
GetFieldCount(FeatureDefn self) -> int
|
|
|
|
int
|
|
OGR_FD_GetFieldCount(OGRFeatureDefnH hDefn)
|
|
|
|
Fetch number of fields on the passed feature definition.
|
|
|
|
This function is the same as the C++ OGRFeatureDefn::GetFieldCount().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hDefn: handle to the feature definition to get the fields count from.
|
|
|
|
count of fields.
|
|
"""
|
|
return _ogr.FeatureDefn_GetFieldCount(self, *args)
|
|
|
|
|
|
def GetFieldDefn(self, *args):
|
|
"""
|
|
GetFieldDefn(FeatureDefn self, int i) -> FieldDefn
|
|
|
|
OGRFieldDefnH
|
|
OGR_FD_GetFieldDefn(OGRFeatureDefnH hDefn, int iField)
|
|
|
|
Fetch field definition of the passed feature definition.
|
|
|
|
This function is the same as the C++ method
|
|
OGRFeatureDefn::GetFieldDefn().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hDefn: handle to the feature definition to get the field definition
|
|
from.
|
|
|
|
iField: the field to fetch, between 0 and GetFieldCount()-1.
|
|
|
|
a handle to an internal field definition object or NULL if invalid
|
|
index. This object should not be modified or freed by the application.
|
|
|
|
"""
|
|
return _ogr.FeatureDefn_GetFieldDefn(self, *args)
|
|
|
|
|
|
def GetFieldIndex(self, *args):
|
|
"""
|
|
GetFieldIndex(FeatureDefn self, char const * field_name) -> int
|
|
|
|
int
|
|
OGR_FD_GetFieldIndex(OGRFeatureDefnH hDefn, const char *pszFieldName)
|
|
|
|
Find field by name.
|
|
|
|
The field index of the first field matching the passed field name
|
|
(case insensitively) is returned.
|
|
|
|
This function is the same as the C++ method
|
|
OGRFeatureDefn::GetFieldIndex.
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hDefn: handle to the feature definition to get field index from.
|
|
|
|
pszFieldName: the field name to search for.
|
|
|
|
the field index, or -1 if no match found.
|
|
"""
|
|
return _ogr.FeatureDefn_GetFieldIndex(self, *args)
|
|
|
|
|
|
def AddFieldDefn(self, *args):
|
|
"""
|
|
AddFieldDefn(FeatureDefn self, FieldDefn defn)
|
|
|
|
void
|
|
OGR_FD_AddFieldDefn(OGRFeatureDefnH hDefn, OGRFieldDefnH hNewField)
|
|
|
|
Add a new field definition to the passed feature definition.
|
|
|
|
To add a new field definition to a layer definition, do not use this
|
|
function directly, but use OGR_L_CreateField() instead.
|
|
|
|
This function should only be called while there are no OGRFeature
|
|
objects in existence based on this OGRFeatureDefn. The OGRFieldDefn
|
|
passed in is copied, and remains the responsibility of the caller.
|
|
|
|
This function is the same as the C++ method
|
|
OGRFeatureDefn::AddFieldDefn().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hDefn: handle to the feature definition to add the field definition
|
|
to.
|
|
|
|
hNewField: handle to the new field definition.
|
|
"""
|
|
return _ogr.FeatureDefn_AddFieldDefn(self, *args)
|
|
|
|
|
|
def GetGeomFieldCount(self, *args):
|
|
"""
|
|
GetGeomFieldCount(FeatureDefn self) -> int
|
|
|
|
int
|
|
OGR_FD_GetGeomFieldCount(OGRFeatureDefnH hDefn)
|
|
|
|
Fetch number of geometry fields on the passed feature definition.
|
|
|
|
This function is the same as the C++
|
|
OGRFeatureDefn::GetGeomFieldCount().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hDefn: handle to the feature definition to get the fields count from.
|
|
|
|
count of geometry fields.
|
|
|
|
GDAL 1.11
|
|
"""
|
|
return _ogr.FeatureDefn_GetGeomFieldCount(self, *args)
|
|
|
|
|
|
def GetGeomFieldDefn(self, *args):
|
|
"""
|
|
GetGeomFieldDefn(FeatureDefn self, int i) -> GeomFieldDefn
|
|
|
|
OGRGeomFieldDefnH
|
|
OGR_FD_GetGeomFieldDefn(OGRFeatureDefnH hDefn, int iGeomField)
|
|
|
|
Fetch geometry field definition of the passed feature definition.
|
|
|
|
This function is the same as the C++ method
|
|
OGRFeatureDefn::GetGeomFieldDefn().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hDefn: handle to the feature definition to get the field definition
|
|
from.
|
|
|
|
iGeomField: the geometry field to fetch, between 0 and
|
|
GetGeomFieldCount() - 1.
|
|
|
|
a handle to an internal field definition object or NULL if invalid
|
|
index. This object should not be modified or freed by the application.
|
|
|
|
GDAL 1.11
|
|
"""
|
|
return _ogr.FeatureDefn_GetGeomFieldDefn(self, *args)
|
|
|
|
|
|
def GetGeomFieldIndex(self, *args):
|
|
"""
|
|
GetGeomFieldIndex(FeatureDefn self, char const * field_name) -> int
|
|
|
|
int
|
|
OGR_FD_GetGeomFieldIndex(OGRFeatureDefnH hDefn, const char
|
|
*pszGeomFieldName)
|
|
|
|
Find geometry field by name.
|
|
|
|
The geometry field index of the first geometry field matching the
|
|
passed field name (case insensitively) is returned.
|
|
|
|
This function is the same as the C++ method
|
|
OGRFeatureDefn::GetGeomFieldIndex.
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hDefn: handle to the feature definition to get field index from.
|
|
|
|
pszGeomFieldName: the geometry field name to search for.
|
|
|
|
the geometry field index, or -1 if no match found.
|
|
"""
|
|
return _ogr.FeatureDefn_GetGeomFieldIndex(self, *args)
|
|
|
|
|
|
def AddGeomFieldDefn(self, *args):
|
|
"""
|
|
AddGeomFieldDefn(FeatureDefn self, GeomFieldDefn defn)
|
|
|
|
void
|
|
OGR_FD_AddGeomFieldDefn(OGRFeatureDefnH hDefn, OGRGeomFieldDefnH
|
|
hNewGeomField)
|
|
|
|
Add a new field definition to the passed feature definition.
|
|
|
|
To add a new field definition to a layer definition, do not use this
|
|
function directly, but use OGR_L_CreateGeomField() instead.
|
|
|
|
This function should only be called while there are no OGRFeature
|
|
objects in existence based on this OGRFeatureDefn. The
|
|
OGRGeomFieldDefn passed in is copied, and remains the responsibility
|
|
of the caller.
|
|
|
|
This function is the same as the C++ method
|
|
OGRFeatureDefn::AddGeomFieldDefn().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hDefn: handle to the feature definition to add the geometry field
|
|
definition to.
|
|
|
|
hNewGeomField: handle to the new field definition.
|
|
|
|
GDAL 1.11
|
|
"""
|
|
return _ogr.FeatureDefn_AddGeomFieldDefn(self, *args)
|
|
|
|
|
|
def DeleteGeomFieldDefn(self, *args):
|
|
"""
|
|
DeleteGeomFieldDefn(FeatureDefn self, int idx) -> OGRErr
|
|
|
|
OGRErr
|
|
OGR_FD_DeleteGeomFieldDefn(OGRFeatureDefnH hDefn, int iGeomField)
|
|
|
|
Delete an existing geometry field definition.
|
|
|
|
To delete an existing geometry field definition from a layer
|
|
definition, do not use this function directly, but use
|
|
OGR_L_DeleteGeomField() instead ( not implemented yet).
|
|
|
|
This method should only be called while there are no OGRFeature
|
|
objects in existence based on this OGRFeatureDefn.
|
|
|
|
This method is the same as the C++ method
|
|
OGRFeatureDefn::DeleteGeomFieldDefn().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hDefn: handle to the feature definition.
|
|
|
|
iGeomField: the index of the geometry field definition.
|
|
|
|
OGRERR_NONE in case of success.
|
|
|
|
GDAL 1.11
|
|
"""
|
|
return _ogr.FeatureDefn_DeleteGeomFieldDefn(self, *args)
|
|
|
|
|
|
def GetGeomType(self, *args):
|
|
"""
|
|
GetGeomType(FeatureDefn self) -> OGRwkbGeometryType
|
|
|
|
OGRwkbGeometryType
|
|
OGR_FD_GetGeomType(OGRFeatureDefnH hDefn)
|
|
|
|
Fetch the geometry base type of the passed feature definition.
|
|
|
|
This function is the same as the C++ method
|
|
OGRFeatureDefn::GetGeomType().
|
|
|
|
Starting with GDAL 1.11, this method returns
|
|
GetGeomFieldDefn(0)->GetType().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hDefn: handle to the feature definition to get the geometry type
|
|
from.
|
|
|
|
the base type for all geometry related to this definition.
|
|
"""
|
|
return _ogr.FeatureDefn_GetGeomType(self, *args)
|
|
|
|
|
|
def SetGeomType(self, *args):
|
|
"""
|
|
SetGeomType(FeatureDefn self, OGRwkbGeometryType geom_type)
|
|
|
|
void
|
|
OGR_FD_SetGeomType(OGRFeatureDefnH hDefn, OGRwkbGeometryType eType)
|
|
|
|
Assign the base geometry type for the passed layer (the same as the
|
|
feature definition).
|
|
|
|
All geometry objects using this type must be of the defined type or a
|
|
derived type. The default upon creation is wkbUnknown which allows for
|
|
any geometry type. The geometry type should generally not be changed
|
|
after any OGRFeatures have been created against this definition.
|
|
|
|
This function is the same as the C++ method
|
|
OGRFeatureDefn::SetGeomType().
|
|
|
|
Starting with GDAL 1.11, this method calls
|
|
GetGeomFieldDefn(0)->SetType().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hDefn: handle to the layer or feature definition to set the geometry
|
|
type to.
|
|
|
|
eType: the new type to assign.
|
|
"""
|
|
return _ogr.FeatureDefn_SetGeomType(self, *args)
|
|
|
|
|
|
def GetReferenceCount(self, *args):
|
|
"""
|
|
GetReferenceCount(FeatureDefn self) -> int
|
|
|
|
int
|
|
OGR_FD_GetReferenceCount(OGRFeatureDefnH hDefn)
|
|
|
|
Fetch current reference count.
|
|
|
|
This function is the same as the C++ method
|
|
OGRFeatureDefn::GetReferenceCount().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hDefn: handle to the feature definition on witch OGRFeature are based
|
|
on.
|
|
|
|
the current reference count.
|
|
"""
|
|
return _ogr.FeatureDefn_GetReferenceCount(self, *args)
|
|
|
|
|
|
def IsGeometryIgnored(self, *args):
|
|
"""
|
|
IsGeometryIgnored(FeatureDefn self) -> int
|
|
|
|
int
|
|
OGR_FD_IsGeometryIgnored(OGRFeatureDefnH hDefn)
|
|
|
|
Determine whether the geometry can be omitted when fetching features.
|
|
|
|
This function is the same as the C++ method
|
|
OGRFeatureDefn::IsGeometryIgnored().
|
|
|
|
Starting with GDAL 1.11, this method returns
|
|
GetGeomFieldDefn(0)->IsIgnored().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hDefn: handle to the feature definition on witch OGRFeature are based
|
|
on.
|
|
|
|
ignore state
|
|
"""
|
|
return _ogr.FeatureDefn_IsGeometryIgnored(self, *args)
|
|
|
|
|
|
def SetGeometryIgnored(self, *args):
|
|
"""
|
|
SetGeometryIgnored(FeatureDefn self, int bIgnored)
|
|
|
|
void
|
|
OGR_FD_SetGeometryIgnored(OGRFeatureDefnH hDefn, int bIgnore)
|
|
|
|
Set whether the geometry can be omitted when fetching features.
|
|
|
|
This function is the same as the C++ method
|
|
OGRFeatureDefn::SetGeometryIgnored().
|
|
|
|
Starting with GDAL 1.11, this method calls
|
|
GetGeomFieldDefn(0)->SetIgnored().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hDefn: handle to the feature definition on witch OGRFeature are based
|
|
on.
|
|
|
|
bIgnore: ignore state
|
|
"""
|
|
return _ogr.FeatureDefn_SetGeometryIgnored(self, *args)
|
|
|
|
|
|
def IsStyleIgnored(self, *args):
|
|
"""
|
|
IsStyleIgnored(FeatureDefn self) -> int
|
|
|
|
int
|
|
OGR_FD_IsStyleIgnored(OGRFeatureDefnH hDefn)
|
|
|
|
Determine whether the style can be omitted when fetching features.
|
|
|
|
This function is the same as the C++ method
|
|
OGRFeatureDefn::IsStyleIgnored().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hDefn: handle to the feature definition on which OGRFeature are based
|
|
on.
|
|
|
|
ignore state
|
|
"""
|
|
return _ogr.FeatureDefn_IsStyleIgnored(self, *args)
|
|
|
|
|
|
def SetStyleIgnored(self, *args):
|
|
"""
|
|
SetStyleIgnored(FeatureDefn self, int bIgnored)
|
|
|
|
void
|
|
OGR_FD_SetStyleIgnored(OGRFeatureDefnH hDefn, int bIgnore)
|
|
|
|
Set whether the style can be omitted when fetching features.
|
|
|
|
This function is the same as the C++ method
|
|
OGRFeatureDefn::SetStyleIgnored().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hDefn: handle to the feature definition on witch OGRFeature are based
|
|
on.
|
|
|
|
bIgnore: ignore state
|
|
"""
|
|
return _ogr.FeatureDefn_SetStyleIgnored(self, *args)
|
|
|
|
|
|
def IsSame(self, *args):
|
|
"""
|
|
IsSame(FeatureDefn self, FeatureDefn other_defn) -> int
|
|
|
|
int OGR_FD_IsSame(OGRFeatureDefnH
|
|
hFDefn, OGRFeatureDefnH hOtherFDefn)
|
|
|
|
Test if the feature definition is identical to the other one.
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hFDefn: handle to the feature definition on witch OGRFeature are
|
|
based on.
|
|
|
|
hOtherFDefn: handle to the other feature definition to compare to.
|
|
|
|
TRUE if the feature definition is identical to the other one.
|
|
|
|
OGR 1.11
|
|
"""
|
|
return _ogr.FeatureDefn_IsSame(self, *args)
|
|
|
|
|
|
def Destroy(self):
|
|
"Once called, self has effectively been destroyed. Do not access. For backwards compatibility only"
|
|
_ogr.delete_FeatureDefn(self)
|
|
self.thisown = 0
|
|
|
|
|
|
FeatureDefn_swigregister = _ogr.FeatureDefn_swigregister
|
|
FeatureDefn_swigregister(FeatureDefn)
|
|
|
|
class FieldDefn(_object):
|
|
"""Proxy of C++ OGRFieldDefnShadow class."""
|
|
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, FieldDefn, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, FieldDefn, name)
|
|
__repr__ = _swig_repr
|
|
__swig_destroy__ = _ogr.delete_FieldDefn
|
|
__del__ = lambda self: None
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
"""__init__(OGRFieldDefnShadow self, char const * name_null_ok, OGRFieldType field_type) -> FieldDefn"""
|
|
this = _ogr.new_FieldDefn(*args, **kwargs)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def GetName(self, *args):
|
|
"""GetName(FieldDefn self) -> char const *"""
|
|
return _ogr.FieldDefn_GetName(self, *args)
|
|
|
|
|
|
def GetNameRef(self, *args):
|
|
"""
|
|
GetNameRef(FieldDefn self) -> char const *
|
|
|
|
const char*
|
|
OGR_Fld_GetNameRef(OGRFieldDefnH hDefn)
|
|
|
|
Fetch name of this field.
|
|
|
|
This function is the same as the CPP method
|
|
OGRFieldDefn::GetNameRef().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hDefn: handle to the field definition.
|
|
|
|
the name of the field definition.
|
|
"""
|
|
return _ogr.FieldDefn_GetNameRef(self, *args)
|
|
|
|
|
|
def SetName(self, *args):
|
|
"""
|
|
SetName(FieldDefn self, char const * name)
|
|
|
|
void OGR_Fld_SetName(OGRFieldDefnH
|
|
hDefn, const char *pszName)
|
|
|
|
Reset the name of this field.
|
|
|
|
This function is the same as the CPP method OGRFieldDefn::SetName().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hDefn: handle to the field definition to apply the new name to.
|
|
|
|
pszName: the new name to apply.
|
|
"""
|
|
return _ogr.FieldDefn_SetName(self, *args)
|
|
|
|
|
|
def GetAlternativeName(self, *args):
|
|
"""GetAlternativeName(FieldDefn self) -> char const *"""
|
|
return _ogr.FieldDefn_GetAlternativeName(self, *args)
|
|
|
|
|
|
def GetAlternativeNameRef(self, *args):
|
|
"""
|
|
GetAlternativeNameRef(FieldDefn self) -> char const *
|
|
|
|
const char*
|
|
OGR_Fld_GetAlternativeNameRef(OGRFieldDefnH hDefn)
|
|
|
|
Fetch the alternative name (or "alias") for this field.
|
|
|
|
The alternative name is an optional attribute for a field which can
|
|
provide a more user-friendly, descriptive name of a field which is not
|
|
subject to the usual naming constraints defined by the data provider.
|
|
|
|
This is a metadata style attribute only: the alternative name cannot
|
|
be used in place of the actual field name during SQL queries or other
|
|
field name dependent API calls.
|
|
|
|
This function is the same as the CPP method
|
|
OGRFieldDefn::GetAlternativeNameRef().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hDefn: handle to the field definition.
|
|
|
|
the alternative name of the field definition.
|
|
|
|
GDAL 3.2
|
|
"""
|
|
return _ogr.FieldDefn_GetAlternativeNameRef(self, *args)
|
|
|
|
|
|
def SetAlternativeName(self, *args):
|
|
"""
|
|
SetAlternativeName(FieldDefn self, char const * alternativeName)
|
|
|
|
void
|
|
OGR_Fld_SetAlternativeName(OGRFieldDefnH hDefn, const char
|
|
*pszAlternativeName)
|
|
|
|
Reset the alternative name (or "alias") for this field.
|
|
|
|
The alternative name is an optional attribute for a field which can
|
|
provide a more user-friendly, descriptive name of a field which is not
|
|
subject to the usual naming constraints defined by the data provider.
|
|
|
|
This is a metadata style attribute only: the alternative name cannot
|
|
be used in place of the actual field name during SQL queries or other
|
|
field name dependent API calls.
|
|
|
|
This function is the same as the CPP method
|
|
OGRFieldDefn::SetAlternativeName().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hDefn: handle to the field definition to apply the new alternative
|
|
name to.
|
|
|
|
pszAlternativeName: the new alternative name to apply.
|
|
|
|
GDAL 3.2
|
|
"""
|
|
return _ogr.FieldDefn_SetAlternativeName(self, *args)
|
|
|
|
|
|
def GetType(self, *args):
|
|
"""
|
|
GetType(FieldDefn self) -> OGRFieldType
|
|
|
|
OGRFieldType
|
|
OGR_Fld_GetType(OGRFieldDefnH hDefn)
|
|
|
|
Fetch type of this field.
|
|
|
|
This function is the same as the CPP method OGRFieldDefn::GetType().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hDefn: handle to the field definition to get type from.
|
|
|
|
field type.
|
|
"""
|
|
return _ogr.FieldDefn_GetType(self, *args)
|
|
|
|
|
|
def SetType(self, *args):
|
|
"""
|
|
SetType(FieldDefn self, OGRFieldType type)
|
|
|
|
void OGR_Fld_SetType(OGRFieldDefnH
|
|
hDefn, OGRFieldType eType)
|
|
|
|
Set the type of this field.
|
|
|
|
This should never be done to an OGRFieldDefn that is already part of
|
|
an OGRFeatureDefn.
|
|
|
|
This function is the same as the CPP method OGRFieldDefn::SetType().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hDefn: handle to the field definition to set type to.
|
|
|
|
eType: the new field type.
|
|
"""
|
|
return _ogr.FieldDefn_SetType(self, *args)
|
|
|
|
|
|
def GetSubType(self, *args):
|
|
"""
|
|
GetSubType(FieldDefn self) -> OGRFieldSubType
|
|
|
|
OGRFieldSubType
|
|
OGR_Fld_GetSubType(OGRFieldDefnH hDefn)
|
|
|
|
Fetch subtype of this field.
|
|
|
|
This function is the same as the CPP method
|
|
OGRFieldDefn::GetSubType().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hDefn: handle to the field definition to get subtype from.
|
|
|
|
field subtype.
|
|
|
|
GDAL 2.0
|
|
"""
|
|
return _ogr.FieldDefn_GetSubType(self, *args)
|
|
|
|
|
|
def SetSubType(self, *args):
|
|
"""
|
|
SetSubType(FieldDefn self, OGRFieldSubType type)
|
|
|
|
void
|
|
OGR_Fld_SetSubType(OGRFieldDefnH hDefn, OGRFieldSubType eSubType)
|
|
|
|
Set the subtype of this field.
|
|
|
|
This should never be done to an OGRFieldDefn that is already part of
|
|
an OGRFeatureDefn.
|
|
|
|
This function is the same as the CPP method
|
|
OGRFieldDefn::SetSubType().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hDefn: handle to the field definition to set type to.
|
|
|
|
eSubType: the new field subtype.
|
|
|
|
GDAL 2.0
|
|
"""
|
|
return _ogr.FieldDefn_SetSubType(self, *args)
|
|
|
|
|
|
def GetJustify(self, *args):
|
|
"""
|
|
GetJustify(FieldDefn self) -> OGRJustification
|
|
|
|
OGRJustification
|
|
OGR_Fld_GetJustify(OGRFieldDefnH hDefn)
|
|
|
|
Get the justification for this field.
|
|
|
|
This function is the same as the CPP method
|
|
OGRFieldDefn::GetJustify().
|
|
|
|
Note: no driver is know to use the concept of field justification.
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hDefn: handle to the field definition to get justification from.
|
|
|
|
the justification.
|
|
"""
|
|
return _ogr.FieldDefn_GetJustify(self, *args)
|
|
|
|
|
|
def SetJustify(self, *args):
|
|
"""
|
|
SetJustify(FieldDefn self, OGRJustification justify)
|
|
|
|
void
|
|
OGR_Fld_SetJustify(OGRFieldDefnH hDefn, OGRJustification eJustify)
|
|
|
|
Set the justification for this field.
|
|
|
|
Note: no driver is know to use the concept of field justification.
|
|
|
|
This function is the same as the CPP method
|
|
OGRFieldDefn::SetJustify().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hDefn: handle to the field definition to set justification to.
|
|
|
|
eJustify: the new justification.
|
|
"""
|
|
return _ogr.FieldDefn_SetJustify(self, *args)
|
|
|
|
|
|
def GetWidth(self, *args):
|
|
"""
|
|
GetWidth(FieldDefn self) -> int
|
|
|
|
int OGR_Fld_GetWidth(OGRFieldDefnH
|
|
hDefn)
|
|
|
|
Get the formatting width for this field.
|
|
|
|
This function is the same as the CPP method OGRFieldDefn::GetWidth().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hDefn: handle to the field definition to get width from.
|
|
|
|
the width, zero means no specified width.
|
|
"""
|
|
return _ogr.FieldDefn_GetWidth(self, *args)
|
|
|
|
|
|
def SetWidth(self, *args):
|
|
"""
|
|
SetWidth(FieldDefn self, int width)
|
|
|
|
void OGR_Fld_SetWidth(OGRFieldDefnH
|
|
hDefn, int nNewWidth)
|
|
|
|
Set the formatting width for this field in characters.
|
|
|
|
This function is the same as the CPP method OGRFieldDefn::SetWidth().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hDefn: handle to the field definition to set width to.
|
|
|
|
nNewWidth: the new width.
|
|
"""
|
|
return _ogr.FieldDefn_SetWidth(self, *args)
|
|
|
|
|
|
def GetPrecision(self, *args):
|
|
"""
|
|
GetPrecision(FieldDefn self) -> int
|
|
|
|
int
|
|
OGR_Fld_GetPrecision(OGRFieldDefnH hDefn)
|
|
|
|
Get the formatting precision for this field.
|
|
|
|
This should normally be zero for fields of types other than OFTReal.
|
|
|
|
This function is the same as the CPP method
|
|
OGRFieldDefn::GetPrecision().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hDefn: handle to the field definition to get precision from.
|
|
|
|
the precision.
|
|
"""
|
|
return _ogr.FieldDefn_GetPrecision(self, *args)
|
|
|
|
|
|
def SetPrecision(self, *args):
|
|
"""
|
|
SetPrecision(FieldDefn self, int precision)
|
|
|
|
void
|
|
OGR_Fld_SetPrecision(OGRFieldDefnH hDefn, int nPrecision)
|
|
|
|
Set the formatting precision for this field in characters.
|
|
|
|
This should normally be zero for fields of types other than OFTReal.
|
|
|
|
This function is the same as the CPP method
|
|
OGRFieldDefn::SetPrecision().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hDefn: handle to the field definition to set precision to.
|
|
|
|
nPrecision: the new precision.
|
|
"""
|
|
return _ogr.FieldDefn_SetPrecision(self, *args)
|
|
|
|
|
|
def GetTypeName(self, *args):
|
|
"""GetTypeName(FieldDefn self) -> char const *"""
|
|
return _ogr.FieldDefn_GetTypeName(self, *args)
|
|
|
|
|
|
def GetFieldTypeName(self, *args):
|
|
"""GetFieldTypeName(FieldDefn self, OGRFieldType type) -> char const *"""
|
|
return _ogr.FieldDefn_GetFieldTypeName(self, *args)
|
|
|
|
|
|
def IsIgnored(self, *args):
|
|
"""
|
|
IsIgnored(FieldDefn self) -> int
|
|
|
|
int OGR_Fld_IsIgnored(OGRFieldDefnH
|
|
hDefn)
|
|
|
|
Return whether this field should be omitted when fetching features.
|
|
|
|
This method is the same as the C++ method OGRFieldDefn::IsIgnored().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hDefn: handle to the field definition
|
|
|
|
ignore state
|
|
"""
|
|
return _ogr.FieldDefn_IsIgnored(self, *args)
|
|
|
|
|
|
def SetIgnored(self, *args):
|
|
"""
|
|
SetIgnored(FieldDefn self, int bIgnored)
|
|
|
|
void
|
|
OGR_Fld_SetIgnored(OGRFieldDefnH hDefn, int ignore)
|
|
|
|
Set whether this field should be omitted when fetching features.
|
|
|
|
This method is the same as the C++ method OGRFieldDefn::SetIgnored().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hDefn: handle to the field definition
|
|
|
|
ignore: ignore state
|
|
"""
|
|
return _ogr.FieldDefn_SetIgnored(self, *args)
|
|
|
|
|
|
def IsNullable(self, *args):
|
|
"""
|
|
IsNullable(FieldDefn self) -> int
|
|
|
|
int
|
|
OGR_Fld_IsNullable(OGRFieldDefnH hDefn)
|
|
|
|
Return whether this field can receive null values.
|
|
|
|
By default, fields are nullable.
|
|
|
|
Even if this method returns FALSE (i.e not-nullable field), it doesn't
|
|
mean that OGRFeature::IsFieldSet() will necessary return TRUE, as
|
|
fields can be temporary unset and null /not-null validation is usually
|
|
done when OGRLayer::CreateFeature()/SetFeature() is called.
|
|
|
|
This method is the same as the C++ method OGRFieldDefn::IsNullable().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hDefn: handle to the field definition
|
|
|
|
TRUE if the field is authorized to be null.
|
|
|
|
GDAL 2.0
|
|
"""
|
|
return _ogr.FieldDefn_IsNullable(self, *args)
|
|
|
|
|
|
def SetNullable(self, *args):
|
|
"""
|
|
SetNullable(FieldDefn self, int bNullable)
|
|
|
|
void
|
|
OGR_Fld_SetNullable(OGRFieldDefnH hDefn, int bNullableIn)
|
|
|
|
Set whether this field can receive null values.
|
|
|
|
By default, fields are nullable, so this method is generally called
|
|
with FALSE to set a not-null constraint.
|
|
|
|
Drivers that support writing not-null constraint will advertise the
|
|
GDAL_DCAP_NOTNULL_FIELDS driver metadata item.
|
|
|
|
This method is the same as the C++ method OGRFieldDefn::SetNullable().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hDefn: handle to the field definition
|
|
|
|
bNullableIn: FALSE if the field must have a not-null constraint.
|
|
|
|
GDAL 2.0
|
|
"""
|
|
return _ogr.FieldDefn_SetNullable(self, *args)
|
|
|
|
|
|
def IsUnique(self, *args):
|
|
"""
|
|
IsUnique(FieldDefn self) -> int
|
|
|
|
int OGR_Fld_IsUnique(OGRFieldDefnH
|
|
hDefn)
|
|
|
|
Return whether this field has a unique constraint.
|
|
|
|
By default, fields have no unique constraint.
|
|
|
|
This method is the same as the C++ method OGRFieldDefn::IsUnique().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hDefn: handle to the field definition
|
|
|
|
TRUE if the field has a unique constraint.
|
|
|
|
GDAL 3.2
|
|
"""
|
|
return _ogr.FieldDefn_IsUnique(self, *args)
|
|
|
|
|
|
def SetUnique(self, *args):
|
|
"""
|
|
SetUnique(FieldDefn self, int bUnique)
|
|
|
|
void
|
|
OGR_Fld_SetUnique(OGRFieldDefnH hDefn, int bUniqueIn)
|
|
|
|
Set whether this field has a unique constraint.
|
|
|
|
By default, fields have no unique constraint, so this method is
|
|
generally called with TRUE to set a unique constraint.
|
|
|
|
Drivers that support writing unique constraint will advertise the
|
|
GDAL_DCAP_UNIQUE_FIELDS driver metadata item. field can receive null
|
|
values.
|
|
|
|
This method is the same as the C++ method OGRFieldDefn::SetUnique().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hDefn: handle to the field definition
|
|
|
|
bUniqueIn: TRUE if the field must have a unique constraint.
|
|
|
|
GDAL 3.2
|
|
"""
|
|
return _ogr.FieldDefn_SetUnique(self, *args)
|
|
|
|
|
|
def GetDefault(self, *args):
|
|
"""
|
|
GetDefault(FieldDefn self) -> char const *
|
|
|
|
const char*
|
|
OGR_Fld_GetDefault(OGRFieldDefnH hDefn)
|
|
|
|
Get default field value.
|
|
|
|
This function is the same as the C++ method
|
|
OGRFieldDefn::GetDefault().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hDefn: handle to the field definition.
|
|
|
|
default field value or NULL.
|
|
|
|
GDAL 2.0
|
|
"""
|
|
return _ogr.FieldDefn_GetDefault(self, *args)
|
|
|
|
|
|
def SetDefault(self, *args):
|
|
"""
|
|
SetDefault(FieldDefn self, char const * pszValue)
|
|
|
|
void
|
|
OGR_Fld_SetDefault(OGRFieldDefnH hDefn, const char *pszDefault)
|
|
|
|
Set default field value.
|
|
|
|
The default field value is taken into account by drivers (generally
|
|
those with a SQL interface) that support it at field creation time.
|
|
OGR will generally not automatically set the default field value to
|
|
null fields by itself when calling OGRFeature::CreateFeature() /
|
|
OGRFeature::SetFeature(), but will let the low-level layers to do the
|
|
job. So retrieving the feature from the layer is recommended.
|
|
|
|
The accepted values are NULL, a numeric value, a literal value
|
|
enclosed between single quote characters (and inner single quote
|
|
characters escaped by repetition of the single quote character),
|
|
CURRENT_TIMESTAMP, CURRENT_TIME, CURRENT_DATE or a driver specific
|
|
expression (that might be ignored by other drivers). For a datetime
|
|
literal value, format should be 'YYYY/MM/DD HH:MM:SS[.sss]'
|
|
(considered as UTC time).
|
|
|
|
Drivers that support writing DEFAULT clauses will advertise the
|
|
GDAL_DCAP_DEFAULT_FIELDS driver metadata item.
|
|
|
|
This function is the same as the C++ method
|
|
OGRFieldDefn::SetDefault().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hDefn: handle to the field definition.
|
|
|
|
pszDefault: new default field value or NULL pointer.
|
|
|
|
GDAL 2.0
|
|
"""
|
|
return _ogr.FieldDefn_SetDefault(self, *args)
|
|
|
|
|
|
def IsDefaultDriverSpecific(self, *args):
|
|
"""
|
|
IsDefaultDriverSpecific(FieldDefn self) -> int
|
|
|
|
int
|
|
OGR_Fld_IsDefaultDriverSpecific(OGRFieldDefnH hDefn)
|
|
|
|
Returns whether the default value is driver specific.
|
|
|
|
Driver specific default values are those that are not NULL, a numeric
|
|
value, a literal value enclosed between single quote characters,
|
|
CURRENT_TIMESTAMP, CURRENT_TIME, CURRENT_DATE or datetime literal
|
|
value.
|
|
|
|
This function is the same as the C++ method
|
|
OGRFieldDefn::IsDefaultDriverSpecific().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hDefn: handle to the field definition
|
|
|
|
TRUE if the default value is driver specific.
|
|
|
|
GDAL 2.0
|
|
"""
|
|
return _ogr.FieldDefn_IsDefaultDriverSpecific(self, *args)
|
|
|
|
|
|
def GetDomainName(self, *args):
|
|
"""GetDomainName(FieldDefn self) -> char const *"""
|
|
return _ogr.FieldDefn_GetDomainName(self, *args)
|
|
|
|
|
|
def SetDomainName(self, *args):
|
|
"""SetDomainName(FieldDefn self, char const * name)"""
|
|
return _ogr.FieldDefn_SetDomainName(self, *args)
|
|
|
|
|
|
width = property(GetWidth, SetWidth)
|
|
type = property(GetType, SetType)
|
|
precision = property(GetPrecision, SetPrecision)
|
|
name = property(GetName, SetName)
|
|
justify = property(GetJustify, SetJustify)
|
|
|
|
|
|
def Destroy(self):
|
|
"Once called, self has effectively been destroyed. Do not access. For backwards compatibility only"
|
|
_ogr.delete_FieldDefn(self)
|
|
self.thisown = 0
|
|
|
|
FieldDefn_swigregister = _ogr.FieldDefn_swigregister
|
|
FieldDefn_swigregister(FieldDefn)
|
|
|
|
class GeomFieldDefn(_object):
|
|
"""Proxy of C++ OGRGeomFieldDefnShadow class."""
|
|
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, GeomFieldDefn, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, GeomFieldDefn, name)
|
|
__repr__ = _swig_repr
|
|
__swig_destroy__ = _ogr.delete_GeomFieldDefn
|
|
__del__ = lambda self: None
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
"""__init__(OGRGeomFieldDefnShadow self, char const * name_null_ok, OGRwkbGeometryType field_type) -> GeomFieldDefn"""
|
|
this = _ogr.new_GeomFieldDefn(*args, **kwargs)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def GetName(self, *args):
|
|
"""GetName(GeomFieldDefn self) -> char const *"""
|
|
return _ogr.GeomFieldDefn_GetName(self, *args)
|
|
|
|
|
|
def GetNameRef(self, *args):
|
|
"""GetNameRef(GeomFieldDefn self) -> char const *"""
|
|
return _ogr.GeomFieldDefn_GetNameRef(self, *args)
|
|
|
|
|
|
def SetName(self, *args):
|
|
"""SetName(GeomFieldDefn self, char const * name)"""
|
|
return _ogr.GeomFieldDefn_SetName(self, *args)
|
|
|
|
|
|
def GetType(self, *args):
|
|
"""GetType(GeomFieldDefn self) -> OGRwkbGeometryType"""
|
|
return _ogr.GeomFieldDefn_GetType(self, *args)
|
|
|
|
|
|
def SetType(self, *args):
|
|
"""SetType(GeomFieldDefn self, OGRwkbGeometryType type)"""
|
|
return _ogr.GeomFieldDefn_SetType(self, *args)
|
|
|
|
|
|
def GetSpatialRef(self, *args):
|
|
"""GetSpatialRef(GeomFieldDefn self) -> SpatialReference"""
|
|
return _ogr.GeomFieldDefn_GetSpatialRef(self, *args)
|
|
|
|
|
|
def SetSpatialRef(self, *args):
|
|
"""SetSpatialRef(GeomFieldDefn self, SpatialReference srs)"""
|
|
return _ogr.GeomFieldDefn_SetSpatialRef(self, *args)
|
|
|
|
|
|
def IsIgnored(self, *args):
|
|
"""IsIgnored(GeomFieldDefn self) -> int"""
|
|
return _ogr.GeomFieldDefn_IsIgnored(self, *args)
|
|
|
|
|
|
def SetIgnored(self, *args):
|
|
"""SetIgnored(GeomFieldDefn self, int bIgnored)"""
|
|
return _ogr.GeomFieldDefn_SetIgnored(self, *args)
|
|
|
|
|
|
def IsNullable(self, *args):
|
|
"""IsNullable(GeomFieldDefn self) -> int"""
|
|
return _ogr.GeomFieldDefn_IsNullable(self, *args)
|
|
|
|
|
|
def SetNullable(self, *args):
|
|
"""SetNullable(GeomFieldDefn self, int bNullable)"""
|
|
return _ogr.GeomFieldDefn_SetNullable(self, *args)
|
|
|
|
|
|
type = property(GetType, SetType)
|
|
name = property(GetName, SetName)
|
|
srs = property(GetSpatialRef, SetSpatialRef)
|
|
|
|
GeomFieldDefn_swigregister = _ogr.GeomFieldDefn_swigregister
|
|
GeomFieldDefn_swigregister(GeomFieldDefn)
|
|
|
|
|
|
def CreateGeometryFromWkb(*args, **kwargs):
|
|
"""CreateGeometryFromWkb(size_t len, SpatialReference reference=None) -> Geometry"""
|
|
return _ogr.CreateGeometryFromWkb(*args, **kwargs)
|
|
|
|
def CreateGeometryFromWkt(*args, **kwargs):
|
|
"""CreateGeometryFromWkt(char ** val, SpatialReference reference=None) -> Geometry"""
|
|
return _ogr.CreateGeometryFromWkt(*args, **kwargs)
|
|
|
|
def CreateGeometryFromGML(*args):
|
|
"""CreateGeometryFromGML(char const * input_string) -> Geometry"""
|
|
return _ogr.CreateGeometryFromGML(*args)
|
|
|
|
def CreateGeometryFromJson(*args):
|
|
"""CreateGeometryFromJson(char const * input_string) -> Geometry"""
|
|
return _ogr.CreateGeometryFromJson(*args)
|
|
|
|
def CreateGeometryFromEsriJson(*args):
|
|
"""CreateGeometryFromEsriJson(char const * input_string) -> Geometry"""
|
|
return _ogr.CreateGeometryFromEsriJson(*args)
|
|
|
|
def BuildPolygonFromEdges(*args, **kwargs):
|
|
"""BuildPolygonFromEdges(Geometry hLineCollection, int bBestEffort=0, int bAutoClose=0, double dfTolerance=0) -> Geometry"""
|
|
return _ogr.BuildPolygonFromEdges(*args, **kwargs)
|
|
|
|
def ApproximateArcAngles(*args, **kwargs):
|
|
"""ApproximateArcAngles(double dfCenterX, double dfCenterY, double dfZ, double dfPrimaryRadius, double dfSecondaryAxis, double dfRotation, double dfStartAngle, double dfEndAngle, double dfMaxAngleStepSizeDegrees) -> Geometry"""
|
|
return _ogr.ApproximateArcAngles(*args, **kwargs)
|
|
|
|
def ForceToPolygon(*args):
|
|
"""ForceToPolygon(Geometry geom_in) -> Geometry"""
|
|
return _ogr.ForceToPolygon(*args)
|
|
|
|
def ForceToLineString(*args):
|
|
"""ForceToLineString(Geometry geom_in) -> Geometry"""
|
|
return _ogr.ForceToLineString(*args)
|
|
|
|
def ForceToMultiPolygon(*args):
|
|
"""ForceToMultiPolygon(Geometry geom_in) -> Geometry"""
|
|
return _ogr.ForceToMultiPolygon(*args)
|
|
|
|
def ForceToMultiPoint(*args):
|
|
"""ForceToMultiPoint(Geometry geom_in) -> Geometry"""
|
|
return _ogr.ForceToMultiPoint(*args)
|
|
|
|
def ForceToMultiLineString(*args):
|
|
"""ForceToMultiLineString(Geometry geom_in) -> Geometry"""
|
|
return _ogr.ForceToMultiLineString(*args)
|
|
|
|
def ForceTo(*args):
|
|
"""ForceTo(Geometry geom_in, OGRwkbGeometryType eTargetType, char ** options=None) -> Geometry"""
|
|
return _ogr.ForceTo(*args)
|
|
class Geometry(_object):
|
|
"""Proxy of C++ OGRGeometryShadow class."""
|
|
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, Geometry, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, Geometry, name)
|
|
__repr__ = _swig_repr
|
|
__swig_destroy__ = _ogr.delete_Geometry
|
|
__del__ = lambda self: None
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
"""__init__(OGRGeometryShadow self, OGRwkbGeometryType type, char * wkt=None, int wkb=0, char * gml=None) -> Geometry"""
|
|
this = _ogr.new_Geometry(*args, **kwargs)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def ExportToWkt(self, *args):
|
|
"""
|
|
ExportToWkt(Geometry self) -> OGRErr
|
|
|
|
OGRErr
|
|
OGR_G_ExportToWkt(OGRGeometryH hGeom, char **ppszSrcText)
|
|
|
|
Convert a geometry into well known text format.
|
|
|
|
This function relates to the SFCOM IWks::ExportToWKT() method.
|
|
|
|
For backward compatibility purposes, it exports the Old-style 99-402
|
|
extended dimension (Z) WKB types for types Point, LineString, Polygon,
|
|
MultiPoint, MultiLineString, MultiPolygon and GeometryCollection. For
|
|
other geometry types, it is equivalent to OGR_G_ExportToIsoWkt().
|
|
|
|
This function is the same as the CPP method
|
|
OGRGeometry::exportToWkt().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hGeom: handle on the geometry to convert to a text format from.
|
|
|
|
ppszSrcText: a text buffer is allocated by the program, and assigned
|
|
to the passed pointer. After use, *ppszDstText should be freed with
|
|
CPLFree().
|
|
|
|
Currently OGRERR_NONE is always returned.
|
|
"""
|
|
return _ogr.Geometry_ExportToWkt(self, *args)
|
|
|
|
|
|
def ExportToIsoWkt(self, *args):
|
|
"""
|
|
ExportToIsoWkt(Geometry self) -> OGRErr
|
|
|
|
OGRErr
|
|
OGR_G_ExportToIsoWkt(OGRGeometryH hGeom, char **ppszSrcText)
|
|
|
|
Convert a geometry into SFSQL 1.2 / ISO SQL/MM Part 3 well known text
|
|
format.
|
|
|
|
This function relates to the SFCOM IWks::ExportToWKT() method. It
|
|
exports the SFSQL 1.2 and ISO SQL/MM Part 3 extended dimension (Z&M)
|
|
WKB types.
|
|
|
|
This function is the same as the CPP method
|
|
OGRGeometry::exportToWkt(wkbVariantIso).
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hGeom: handle on the geometry to convert to a text format from.
|
|
|
|
ppszSrcText: a text buffer is allocated by the program, and assigned
|
|
to the passed pointer. After use, *ppszDstText should be freed with
|
|
CPLFree().
|
|
|
|
Currently OGRERR_NONE is always returned.
|
|
|
|
GDAL 2.0
|
|
"""
|
|
return _ogr.Geometry_ExportToIsoWkt(self, *args)
|
|
|
|
|
|
def ExportToWkb(self, *args, **kwargs):
|
|
"""
|
|
ExportToWkb(Geometry self, OGRwkbByteOrder byte_order) -> OGRErr
|
|
|
|
OGRErr
|
|
OGR_G_ExportToWkb(OGRGeometryH hGeom, OGRwkbByteOrder eOrder, unsigned
|
|
char *pabyDstBuffer)
|
|
|
|
Convert a geometry well known binary format.
|
|
|
|
This function relates to the SFCOM IWks::ExportToWKB() method.
|
|
|
|
For backward compatibility purposes, it exports the Old-style 99-402
|
|
extended dimension (Z) WKB types for types Point, LineString, Polygon,
|
|
MultiPoint, MultiLineString, MultiPolygon and GeometryCollection. For
|
|
other geometry types, it is equivalent to OGR_G_ExportToIsoWkb().
|
|
|
|
This function is the same as the CPP method
|
|
OGRGeometry::exportToWkb(OGRwkbByteOrder, unsigned char *,
|
|
OGRwkbVariant) with eWkbVariant = wkbVariantOldOgc.
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hGeom: handle on the geometry to convert to a well know binary data
|
|
from.
|
|
|
|
eOrder: One of wkbXDR or wkbNDR indicating MSB or LSB byte order
|
|
respectively.
|
|
|
|
pabyDstBuffer: a buffer into which the binary representation is
|
|
written. This buffer must be at least OGR_G_WkbSize() byte in size.
|
|
|
|
Currently OGRERR_NONE is always returned.
|
|
"""
|
|
return _ogr.Geometry_ExportToWkb(self, *args, **kwargs)
|
|
|
|
|
|
def ExportToIsoWkb(self, *args, **kwargs):
|
|
"""
|
|
ExportToIsoWkb(Geometry self, OGRwkbByteOrder byte_order) -> OGRErr
|
|
|
|
OGRErr
|
|
OGR_G_ExportToIsoWkb(OGRGeometryH hGeom, OGRwkbByteOrder eOrder,
|
|
unsigned char *pabyDstBuffer)
|
|
|
|
Convert a geometry into SFSQL 1.2 / ISO SQL/MM Part 3 well known
|
|
binary format.
|
|
|
|
This function relates to the SFCOM IWks::ExportToWKB() method. It
|
|
exports the SFSQL 1.2 and ISO SQL/MM Part 3 extended dimension (Z&M)
|
|
WKB types.
|
|
|
|
This function is the same as the CPP method
|
|
OGRGeometry::exportToWkb(OGRwkbByteOrder, unsigned char *,
|
|
OGRwkbVariant) with eWkbVariant = wkbVariantIso.
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hGeom: handle on the geometry to convert to a well know binary data
|
|
from.
|
|
|
|
eOrder: One of wkbXDR or wkbNDR indicating MSB or LSB byte order
|
|
respectively.
|
|
|
|
pabyDstBuffer: a buffer into which the binary representation is
|
|
written. This buffer must be at least OGR_G_WkbSize() byte in size.
|
|
|
|
Currently OGRERR_NONE is always returned.
|
|
|
|
GDAL 2.0
|
|
"""
|
|
return _ogr.Geometry_ExportToIsoWkb(self, *args, **kwargs)
|
|
|
|
|
|
def ExportToGML(self, *args, **kwargs):
|
|
"""ExportToGML(Geometry self, char ** options=None) -> retStringAndCPLFree *"""
|
|
return _ogr.Geometry_ExportToGML(self, *args, **kwargs)
|
|
|
|
|
|
def ExportToKML(self, *args):
|
|
"""ExportToKML(Geometry self, char const * altitude_mode=None) -> retStringAndCPLFree *"""
|
|
return _ogr.Geometry_ExportToKML(self, *args)
|
|
|
|
|
|
def ExportToJson(self, *args, **kwargs):
|
|
"""ExportToJson(Geometry self, char ** options=None) -> retStringAndCPLFree *"""
|
|
return _ogr.Geometry_ExportToJson(self, *args, **kwargs)
|
|
|
|
|
|
def AddPoint(self, *args, **kwargs):
|
|
"""AddPoint(Geometry self, double x, double y, double z=0)"""
|
|
return _ogr.Geometry_AddPoint(self, *args, **kwargs)
|
|
|
|
|
|
def AddPointM(self, *args, **kwargs):
|
|
"""AddPointM(Geometry self, double x, double y, double m)"""
|
|
return _ogr.Geometry_AddPointM(self, *args, **kwargs)
|
|
|
|
|
|
def AddPointZM(self, *args, **kwargs):
|
|
"""AddPointZM(Geometry self, double x, double y, double z, double m)"""
|
|
return _ogr.Geometry_AddPointZM(self, *args, **kwargs)
|
|
|
|
|
|
def AddPoint_2D(self, *args):
|
|
"""AddPoint_2D(Geometry self, double x, double y)"""
|
|
return _ogr.Geometry_AddPoint_2D(self, *args)
|
|
|
|
|
|
def AddGeometryDirectly(self, *args):
|
|
"""AddGeometryDirectly(Geometry self, Geometry other_disown) -> OGRErr"""
|
|
return _ogr.Geometry_AddGeometryDirectly(self, *args)
|
|
|
|
|
|
def AddGeometry(self, *args):
|
|
"""AddGeometry(Geometry self, Geometry other) -> OGRErr"""
|
|
return _ogr.Geometry_AddGeometry(self, *args)
|
|
|
|
|
|
def RemoveGeometry(self, *args):
|
|
"""RemoveGeometry(Geometry self, int iSubGeom) -> OGRErr"""
|
|
return _ogr.Geometry_RemoveGeometry(self, *args)
|
|
|
|
|
|
def Clone(self, *args):
|
|
"""
|
|
Clone(Geometry self) -> Geometry
|
|
|
|
OGRGeometryH OGR_G_Clone(OGRGeometryH
|
|
hGeom)
|
|
|
|
Make a copy of this object.
|
|
|
|
This function relates to the SFCOM IGeometry::clone() method.
|
|
|
|
This function is the same as the CPP method OGRGeometry::clone().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hGeom: handle on the geometry to clone from.
|
|
|
|
a handle on the copy of the geometry with the spatial reference
|
|
system as the original.
|
|
"""
|
|
return _ogr.Geometry_Clone(self, *args)
|
|
|
|
|
|
def GetGeometryType(self, *args):
|
|
"""
|
|
GetGeometryType(Geometry self) -> OGRwkbGeometryType
|
|
|
|
OGRwkbGeometryType
|
|
OGR_G_GetGeometryType(OGRGeometryH hGeom)
|
|
|
|
Fetch geometry type.
|
|
|
|
Note that the geometry type may include the 2.5D flag. To get a 2D
|
|
flattened version of the geometry type apply the wkbFlatten() macro to
|
|
the return result.
|
|
|
|
This function is the same as the CPP method
|
|
OGRGeometry::getGeometryType().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hGeom: handle on the geometry to get type from.
|
|
|
|
the geometry type code.
|
|
"""
|
|
return _ogr.Geometry_GetGeometryType(self, *args)
|
|
|
|
|
|
def GetGeometryName(self, *args):
|
|
"""
|
|
GetGeometryName(Geometry self) -> char const *
|
|
|
|
const char*
|
|
OGR_G_GetGeometryName(OGRGeometryH hGeom)
|
|
|
|
Fetch WKT name for geometry type.
|
|
|
|
There is no SFCOM analog to this function.
|
|
|
|
This function is the same as the CPP method
|
|
OGRGeometry::getGeometryName().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hGeom: handle on the geometry to get name from.
|
|
|
|
name used for this geometry type in well known text format.
|
|
"""
|
|
return _ogr.Geometry_GetGeometryName(self, *args)
|
|
|
|
|
|
def Length(self, *args):
|
|
"""Length(Geometry self) -> double"""
|
|
return _ogr.Geometry_Length(self, *args)
|
|
|
|
|
|
def Area(self, *args):
|
|
"""Area(Geometry self) -> double"""
|
|
return _ogr.Geometry_Area(self, *args)
|
|
|
|
|
|
def GetArea(self, *args):
|
|
"""GetArea(Geometry self) -> double"""
|
|
return _ogr.Geometry_GetArea(self, *args)
|
|
|
|
|
|
def GetPointCount(self, *args):
|
|
"""GetPointCount(Geometry self) -> int"""
|
|
return _ogr.Geometry_GetPointCount(self, *args)
|
|
|
|
|
|
def GetPoints(self, *args, **kwargs):
|
|
"""GetPoints(Geometry self, int nCoordDimension=0)"""
|
|
return _ogr.Geometry_GetPoints(self, *args, **kwargs)
|
|
|
|
|
|
def GetX(self, *args, **kwargs):
|
|
"""GetX(Geometry self, int point=0) -> double"""
|
|
return _ogr.Geometry_GetX(self, *args, **kwargs)
|
|
|
|
|
|
def GetY(self, *args, **kwargs):
|
|
"""GetY(Geometry self, int point=0) -> double"""
|
|
return _ogr.Geometry_GetY(self, *args, **kwargs)
|
|
|
|
|
|
def GetZ(self, *args, **kwargs):
|
|
"""GetZ(Geometry self, int point=0) -> double"""
|
|
return _ogr.Geometry_GetZ(self, *args, **kwargs)
|
|
|
|
|
|
def GetM(self, *args, **kwargs):
|
|
"""GetM(Geometry self, int point=0) -> double"""
|
|
return _ogr.Geometry_GetM(self, *args, **kwargs)
|
|
|
|
|
|
def GetPoint(self, *args):
|
|
"""GetPoint(Geometry self, int iPoint=0)"""
|
|
return _ogr.Geometry_GetPoint(self, *args)
|
|
|
|
|
|
def GetPointZM(self, *args):
|
|
"""GetPointZM(Geometry self, int iPoint=0)"""
|
|
return _ogr.Geometry_GetPointZM(self, *args)
|
|
|
|
|
|
def GetPoint_2D(self, *args):
|
|
"""GetPoint_2D(Geometry self, int iPoint=0)"""
|
|
return _ogr.Geometry_GetPoint_2D(self, *args)
|
|
|
|
|
|
def GetGeometryCount(self, *args):
|
|
"""GetGeometryCount(Geometry self) -> int"""
|
|
return _ogr.Geometry_GetGeometryCount(self, *args)
|
|
|
|
|
|
def SetPoint(self, *args, **kwargs):
|
|
"""SetPoint(Geometry self, int point, double x, double y, double z=0)"""
|
|
return _ogr.Geometry_SetPoint(self, *args, **kwargs)
|
|
|
|
|
|
def SetPointM(self, *args, **kwargs):
|
|
"""SetPointM(Geometry self, int point, double x, double y, double m)"""
|
|
return _ogr.Geometry_SetPointM(self, *args, **kwargs)
|
|
|
|
|
|
def SetPointZM(self, *args, **kwargs):
|
|
"""SetPointZM(Geometry self, int point, double x, double y, double z, double m)"""
|
|
return _ogr.Geometry_SetPointZM(self, *args, **kwargs)
|
|
|
|
|
|
def SetPoint_2D(self, *args, **kwargs):
|
|
"""SetPoint_2D(Geometry self, int point, double x, double y)"""
|
|
return _ogr.Geometry_SetPoint_2D(self, *args, **kwargs)
|
|
|
|
|
|
def SwapXY(self, *args):
|
|
"""
|
|
SwapXY(Geometry self)
|
|
|
|
void OGR_G_SwapXY(OGRGeometryH hGeom)
|
|
|
|
Swap x and y coordinates.
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hGeom: geometry.
|
|
|
|
OGR 2.3.0
|
|
"""
|
|
return _ogr.Geometry_SwapXY(self, *args)
|
|
|
|
|
|
def GetGeometryRef(self, *args):
|
|
"""GetGeometryRef(Geometry self, int geom) -> Geometry"""
|
|
return _ogr.Geometry_GetGeometryRef(self, *args)
|
|
|
|
|
|
def Simplify(self, *args):
|
|
"""
|
|
Simplify(Geometry self, double tolerance) -> Geometry
|
|
|
|
OGRGeometryH
|
|
OGR_G_Simplify(OGRGeometryH hThis, double dTolerance)
|
|
|
|
Compute a simplified geometry.
|
|
|
|
This function is the same as the C++ method OGRGeometry::Simplify().
|
|
|
|
This function is built on the GEOS library, check it for the
|
|
definition of the geometry operation. If OGR is built without the GEOS
|
|
library, this function will always fail, issuing a CPLE_NotSupported
|
|
error.
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hThis: the geometry.
|
|
|
|
dTolerance: the distance tolerance for the simplification.
|
|
|
|
the simplified geometry or NULL if an error occurs.
|
|
|
|
OGR 1.8.0
|
|
"""
|
|
return _ogr.Geometry_Simplify(self, *args)
|
|
|
|
|
|
def SimplifyPreserveTopology(self, *args):
|
|
"""
|
|
SimplifyPreserveTopology(Geometry self, double tolerance) -> Geometry
|
|
|
|
OGRGeometryH
|
|
OGR_G_SimplifyPreserveTopology(OGRGeometryH hThis, double dTolerance)
|
|
|
|
Simplify the geometry while preserving topology.
|
|
|
|
This function is the same as the C++ method
|
|
OGRGeometry::SimplifyPreserveTopology().
|
|
|
|
This function is built on the GEOS library, check it for the
|
|
definition of the geometry operation. If OGR is built without the GEOS
|
|
library, this function will always fail, issuing a CPLE_NotSupported
|
|
error.
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hThis: the geometry.
|
|
|
|
dTolerance: the distance tolerance for the simplification.
|
|
|
|
the simplified geometry or NULL if an error occurs.
|
|
|
|
OGR 1.9.0
|
|
"""
|
|
return _ogr.Geometry_SimplifyPreserveTopology(self, *args)
|
|
|
|
|
|
def DelaunayTriangulation(self, *args, **kwargs):
|
|
"""
|
|
DelaunayTriangulation(Geometry self, double dfTolerance=0.0, int bOnlyEdges=False) -> Geometry
|
|
|
|
OGRGeometryH
|
|
OGR_G_DelaunayTriangulation(OGRGeometryH hThis, double dfTolerance,
|
|
int bOnlyEdges)
|
|
|
|
Return a Delaunay triangulation of the vertices of the geometry.
|
|
|
|
This function is the same as the C++ method
|
|
OGRGeometry::DelaunayTriangulation().
|
|
|
|
This function is built on the GEOS library, v3.4 or above. If OGR is
|
|
built without the GEOS library, this function will always fail,
|
|
issuing a CPLE_NotSupported error.
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hThis: the geometry.
|
|
|
|
dfTolerance: optional snapping tolerance to use for improved
|
|
robustness
|
|
|
|
bOnlyEdges: if TRUE, will return a MULTILINESTRING, otherwise it will
|
|
return a GEOMETRYCOLLECTION containing triangular POLYGONs.
|
|
|
|
the geometry resulting from the Delaunay triangulation or NULL if an
|
|
error occurs.
|
|
|
|
OGR 2.1
|
|
"""
|
|
return _ogr.Geometry_DelaunayTriangulation(self, *args, **kwargs)
|
|
|
|
|
|
def Polygonize(self, *args):
|
|
"""
|
|
Polygonize(Geometry self) -> Geometry
|
|
|
|
OGRGeometryH
|
|
OGR_G_Polygonize(OGRGeometryH hTarget)
|
|
|
|
Polygonizes a set of sparse edges.
|
|
|
|
A new geometry object is created and returned containing a collection
|
|
of reassembled Polygons: NULL will be returned if the input collection
|
|
doesn't corresponds to a MultiLinestring, or when reassembling Edges
|
|
into Polygons is impossible due to topological inconsistencies.
|
|
|
|
This function is the same as the C++ method OGRGeometry::Polygonize().
|
|
|
|
This function is built on the GEOS library, check it for the
|
|
definition of the geometry operation. If OGR is built without the GEOS
|
|
library, this function will always fail, issuing a CPLE_NotSupported
|
|
error.
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hTarget: The Geometry to be polygonized.
|
|
|
|
a handle to a newly allocated geometry now owned by the caller, or
|
|
NULL on failure.
|
|
|
|
OGR 1.9.0
|
|
"""
|
|
return _ogr.Geometry_Polygonize(self, *args)
|
|
|
|
|
|
def Boundary(self, *args):
|
|
"""
|
|
Boundary(Geometry self) -> Geometry
|
|
|
|
OGRGeometryH
|
|
OGR_G_Boundary(OGRGeometryH hTarget)
|
|
|
|
Compute boundary.
|
|
|
|
A new geometry object is created and returned containing the boundary
|
|
of the geometry on which the method is invoked.
|
|
|
|
This function is the same as the C++ method OGR_G_Boundary().
|
|
|
|
This function is built on the GEOS library, check it for the
|
|
definition of the geometry operation. If OGR is built without the GEOS
|
|
library, this function will always fail, issuing a CPLE_NotSupported
|
|
error.
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hTarget: The Geometry to calculate the boundary of.
|
|
|
|
a handle to a newly allocated geometry now owned by the caller, or
|
|
NULL on failure.
|
|
|
|
OGR 1.8.0
|
|
"""
|
|
return _ogr.Geometry_Boundary(self, *args)
|
|
|
|
|
|
def GetBoundary(self, *args):
|
|
"""
|
|
GetBoundary(Geometry self) -> Geometry
|
|
|
|
OGRGeometryH
|
|
OGR_G_GetBoundary(OGRGeometryH hTarget)
|
|
|
|
Compute boundary (deprecated)
|
|
|
|
Deprecated
|
|
|
|
See: OGR_G_Boundary()
|
|
"""
|
|
return _ogr.Geometry_GetBoundary(self, *args)
|
|
|
|
|
|
def ConvexHull(self, *args):
|
|
"""
|
|
ConvexHull(Geometry self) -> Geometry
|
|
|
|
OGRGeometryH
|
|
OGR_G_ConvexHull(OGRGeometryH hTarget)
|
|
|
|
Compute convex hull.
|
|
|
|
A new geometry object is created and returned containing the convex
|
|
hull of the geometry on which the method is invoked.
|
|
|
|
This function is the same as the C++ method OGRGeometry::ConvexHull().
|
|
|
|
This function is built on the GEOS library, check it for the
|
|
definition of the geometry operation. If OGR is built without the GEOS
|
|
library, this function will always fail, issuing a CPLE_NotSupported
|
|
error.
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hTarget: The Geometry to calculate the convex hull of.
|
|
|
|
a handle to a newly allocated geometry now owned by the caller, or
|
|
NULL on failure.
|
|
"""
|
|
return _ogr.Geometry_ConvexHull(self, *args)
|
|
|
|
|
|
def MakeValid(self, *args):
|
|
"""
|
|
MakeValid(Geometry self) -> Geometry
|
|
|
|
OGRGeometryH
|
|
OGR_G_MakeValid(OGRGeometryH hGeom)
|
|
|
|
Attempts to make an invalid geometry valid without losing vertices.
|
|
|
|
Already-valid geometries are cloned without further intervention.
|
|
|
|
This function is the same as the C++ method OGRGeometry::MakeValid().
|
|
|
|
This function is built on the GEOS >= 3.8 library, check it for the
|
|
definition of the geometry operation. If OGR is built without the GEOS
|
|
>= 3.8 library, this function will return a clone of the input
|
|
geometry if it is valid, or NULL if it is invalid
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hGeom: The Geometry to make valid.
|
|
|
|
a newly allocated geometry now owned by the caller, or NULL on
|
|
failure.
|
|
|
|
GDAL 3.0
|
|
"""
|
|
return _ogr.Geometry_MakeValid(self, *args)
|
|
|
|
|
|
def Normalize(self, *args):
|
|
"""Normalize(Geometry self) -> Geometry"""
|
|
return _ogr.Geometry_Normalize(self, *args)
|
|
|
|
|
|
def RemoveLowerDimensionSubGeoms(self, *args):
|
|
"""RemoveLowerDimensionSubGeoms(Geometry self) -> Geometry"""
|
|
return _ogr.Geometry_RemoveLowerDimensionSubGeoms(self, *args)
|
|
|
|
|
|
def Buffer(self, *args, **kwargs):
|
|
"""
|
|
Buffer(Geometry self, double distance, int quadsecs=30) -> Geometry
|
|
|
|
OGRGeometryH OGR_G_Buffer(OGRGeometryH
|
|
hTarget, double dfDist, int nQuadSegs)
|
|
|
|
Compute buffer of geometry.
|
|
|
|
Builds a new geometry containing the buffer region around the geometry
|
|
on which it is invoked. The buffer is a polygon containing the region
|
|
within the buffer distance of the original geometry.
|
|
|
|
Some buffer sections are properly described as curves, but are
|
|
converted to approximate polygons. The nQuadSegs parameter can be used
|
|
to control how many segments should be used to define a 90 degree
|
|
curve - a quadrant of a circle. A value of 30 is a reasonable default.
|
|
Large values result in large numbers of vertices in the resulting
|
|
buffer geometry while small numbers reduce the accuracy of the result.
|
|
|
|
This function is the same as the C++ method OGRGeometry::Buffer().
|
|
|
|
This function is built on the GEOS library, check it for the
|
|
definition of the geometry operation. If OGR is built without the GEOS
|
|
library, this function will always fail, issuing a CPLE_NotSupported
|
|
error.
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hTarget: the geometry.
|
|
|
|
dfDist: the buffer distance to be applied. Should be expressed into
|
|
the same unit as the coordinates of the geometry.
|
|
|
|
nQuadSegs: the number of segments used to approximate a 90 degree
|
|
(quadrant) of curvature.
|
|
|
|
the newly created geometry, or NULL if an error occurs.
|
|
"""
|
|
return _ogr.Geometry_Buffer(self, *args, **kwargs)
|
|
|
|
|
|
def Intersection(self, *args):
|
|
"""
|
|
Intersection(Geometry self, Geometry other) -> Geometry
|
|
|
|
OGRGeometryH
|
|
OGR_G_Intersection(OGRGeometryH hThis, OGRGeometryH hOther)
|
|
|
|
Compute intersection.
|
|
|
|
Generates a new geometry which is the region of intersection of the
|
|
two geometries operated on. The OGR_G_Intersects() function can be
|
|
used to test if two geometries intersect.
|
|
|
|
Geometry validity is not checked. In case you are unsure of the
|
|
validity of the input geometries, call IsValid() before, otherwise the
|
|
result might be wrong.
|
|
|
|
This function is the same as the C++ method
|
|
OGRGeometry::Intersection().
|
|
|
|
This function is built on the GEOS library, check it for the
|
|
definition of the geometry operation. If OGR is built without the GEOS
|
|
library, this function will always fail, issuing a CPLE_NotSupported
|
|
error.
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hThis: the geometry.
|
|
|
|
hOther: the other geometry.
|
|
|
|
a new geometry representing the intersection or NULL if there is no
|
|
intersection or an error occurs.
|
|
"""
|
|
return _ogr.Geometry_Intersection(self, *args)
|
|
|
|
|
|
def Union(self, *args):
|
|
"""
|
|
Union(Geometry self, Geometry other) -> Geometry
|
|
|
|
OGRGeometryH OGR_G_Union(OGRGeometryH
|
|
hThis, OGRGeometryH hOther)
|
|
|
|
Compute union.
|
|
|
|
Generates a new geometry which is the region of union of the two
|
|
geometries operated on.
|
|
|
|
Geometry validity is not checked. In case you are unsure of the
|
|
validity of the input geometries, call IsValid() before, otherwise the
|
|
result might be wrong.
|
|
|
|
This function is the same as the C++ method OGRGeometry::Union().
|
|
|
|
This function is built on the GEOS library, check it for the
|
|
definition of the geometry operation. If OGR is built without the GEOS
|
|
library, this function will always fail, issuing a CPLE_NotSupported
|
|
error.
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hThis: the geometry.
|
|
|
|
hOther: the other geometry.
|
|
|
|
a new geometry representing the union or NULL if an error occurs.
|
|
"""
|
|
return _ogr.Geometry_Union(self, *args)
|
|
|
|
|
|
def UnionCascaded(self, *args):
|
|
"""
|
|
UnionCascaded(Geometry self) -> Geometry
|
|
|
|
OGRGeometryH
|
|
OGR_G_UnionCascaded(OGRGeometryH hThis)
|
|
|
|
Compute union using cascading.
|
|
|
|
Geometry validity is not checked. In case you are unsure of the
|
|
validity of the input geometries, call IsValid() before, otherwise the
|
|
result might be wrong.
|
|
|
|
This function is the same as the C++ method
|
|
OGRGeometry::UnionCascaded().
|
|
|
|
This function is built on the GEOS library, check it for the
|
|
definition of the geometry operation. If OGR is built without the GEOS
|
|
library, this function will always fail, issuing a CPLE_NotSupported
|
|
error.
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hThis: the geometry.
|
|
|
|
a new geometry representing the union or NULL if an error occurs.
|
|
"""
|
|
return _ogr.Geometry_UnionCascaded(self, *args)
|
|
|
|
|
|
def Difference(self, *args):
|
|
"""
|
|
Difference(Geometry self, Geometry other) -> Geometry
|
|
|
|
OGRGeometryH
|
|
OGR_G_Difference(OGRGeometryH hThis, OGRGeometryH hOther)
|
|
|
|
Compute difference.
|
|
|
|
Generates a new geometry which is the region of this geometry with the
|
|
region of the other geometry removed.
|
|
|
|
Geometry validity is not checked. In case you are unsure of the
|
|
validity of the input geometries, call IsValid() before, otherwise the
|
|
result might be wrong.
|
|
|
|
This function is the same as the C++ method OGRGeometry::Difference().
|
|
|
|
This function is built on the GEOS library, check it for the
|
|
definition of the geometry operation. If OGR is built without the GEOS
|
|
library, this function will always fail, issuing a CPLE_NotSupported
|
|
error.
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hThis: the geometry.
|
|
|
|
hOther: the other geometry.
|
|
|
|
a new geometry representing the difference or NULL if the difference
|
|
is empty or an error occurs.
|
|
"""
|
|
return _ogr.Geometry_Difference(self, *args)
|
|
|
|
|
|
def SymDifference(self, *args):
|
|
"""
|
|
SymDifference(Geometry self, Geometry other) -> Geometry
|
|
|
|
OGRGeometryH
|
|
OGR_G_SymDifference(OGRGeometryH hThis, OGRGeometryH hOther)
|
|
|
|
Compute symmetric difference.
|
|
|
|
Generates a new geometry which is the symmetric difference of this
|
|
geometry and the other geometry.
|
|
|
|
Geometry validity is not checked. In case you are unsure of the
|
|
validity of the input geometries, call IsValid() before, otherwise the
|
|
result might be wrong.
|
|
|
|
This function is the same as the C++ method
|
|
OGRGeometry::SymmetricDifference().
|
|
|
|
This function is built on the GEOS library, check it for the
|
|
definition of the geometry operation. If OGR is built without the GEOS
|
|
library, this function will always fail, issuing a CPLE_NotSupported
|
|
error.
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hThis: the geometry.
|
|
|
|
hOther: the other geometry.
|
|
|
|
a new geometry representing the symmetric difference or NULL if the
|
|
difference is empty or an error occurs.
|
|
|
|
OGR 1.8.0
|
|
"""
|
|
return _ogr.Geometry_SymDifference(self, *args)
|
|
|
|
|
|
def SymmetricDifference(self, *args):
|
|
"""
|
|
SymmetricDifference(Geometry self, Geometry other) -> Geometry
|
|
|
|
OGRGeometryH
|
|
OGR_G_SymmetricDifference(OGRGeometryH hThis, OGRGeometryH hOther)
|
|
|
|
Compute symmetric difference (deprecated)
|
|
|
|
Deprecated
|
|
|
|
See: OGR_G_SymmetricDifference()
|
|
"""
|
|
return _ogr.Geometry_SymmetricDifference(self, *args)
|
|
|
|
|
|
def Distance(self, *args):
|
|
"""
|
|
Distance(Geometry self, Geometry other) -> double
|
|
|
|
double OGR_G_Distance(OGRGeometryH
|
|
hFirst, OGRGeometryH hOther)
|
|
|
|
Compute distance between two geometries.
|
|
|
|
Returns the shortest distance between the two geometries. The distance
|
|
is expressed into the same unit as the coordinates of the geometries.
|
|
|
|
This function is the same as the C++ method OGRGeometry::Distance().
|
|
|
|
This function is built on the GEOS library, check it for the
|
|
definition of the geometry operation. If OGR is built without the GEOS
|
|
library, this function will always fail, issuing a CPLE_NotSupported
|
|
error.
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hFirst: the first geometry to compare against.
|
|
|
|
hOther: the other geometry to compare against.
|
|
|
|
the distance between the geometries or -1 if an error occurs.
|
|
"""
|
|
return _ogr.Geometry_Distance(self, *args)
|
|
|
|
|
|
def Distance3D(self, *args):
|
|
"""
|
|
Distance3D(Geometry self, Geometry other) -> double
|
|
|
|
double
|
|
OGR_G_Distance3D(OGRGeometryH hFirst, OGRGeometryH hOther)
|
|
|
|
Returns the 3D distance between two geometries.
|
|
|
|
The distance is expressed into the same unit as the coordinates of the
|
|
geometries.
|
|
|
|
This method is built on the SFCGAL library, check it for the
|
|
definition of the geometry operation. If OGR is built without the
|
|
SFCGAL library, this method will always return -1.0
|
|
|
|
This function is the same as the C++ method OGRGeometry::Distance3D().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hFirst: the first geometry to compare against.
|
|
|
|
hOther: the other geometry to compare against.
|
|
|
|
distance between the two geometries
|
|
|
|
GDAL 2.2
|
|
|
|
the distance between the geometries or -1 if an error occurs.
|
|
"""
|
|
return _ogr.Geometry_Distance3D(self, *args)
|
|
|
|
|
|
def Empty(self, *args):
|
|
"""
|
|
Empty(Geometry self)
|
|
|
|
void OGR_G_Empty(OGRGeometryH hGeom)
|
|
|
|
Clear geometry information.
|
|
|
|
This restores the geometry to its initial state after construction,
|
|
and before assignment of actual geometry.
|
|
|
|
This function relates to the SFCOM IGeometry::Empty() method.
|
|
|
|
This function is the same as the CPP method OGRGeometry::empty().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hGeom: handle on the geometry to empty.
|
|
"""
|
|
return _ogr.Geometry_Empty(self, *args)
|
|
|
|
|
|
def IsEmpty(self, *args):
|
|
"""
|
|
IsEmpty(Geometry self) -> bool
|
|
|
|
int OGR_G_IsEmpty(OGRGeometryH hGeom)
|
|
|
|
Test if the geometry is empty.
|
|
|
|
This method is the same as the CPP method OGRGeometry::IsEmpty().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hGeom: The Geometry to test.
|
|
|
|
TRUE if the geometry has no points, otherwise FALSE.
|
|
"""
|
|
return _ogr.Geometry_IsEmpty(self, *args)
|
|
|
|
|
|
def IsValid(self, *args):
|
|
"""
|
|
IsValid(Geometry self) -> bool
|
|
|
|
int OGR_G_IsValid(OGRGeometryH hGeom)
|
|
|
|
Test if the geometry is valid.
|
|
|
|
This function is the same as the C++ method OGRGeometry::IsValid().
|
|
|
|
This function is built on the GEOS library, check it for the
|
|
definition of the geometry operation. If OGR is built without the GEOS
|
|
library, this function will always return FALSE.
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hGeom: The Geometry to test.
|
|
|
|
TRUE if the geometry has no points, otherwise FALSE.
|
|
"""
|
|
return _ogr.Geometry_IsValid(self, *args)
|
|
|
|
|
|
def IsSimple(self, *args):
|
|
"""
|
|
IsSimple(Geometry self) -> bool
|
|
|
|
int OGR_G_IsSimple(OGRGeometryH
|
|
hGeom)
|
|
|
|
Returns TRUE if the geometry is simple.
|
|
|
|
Returns TRUE if the geometry has no anomalous geometric points, such
|
|
as self intersection or self tangency. The description of each
|
|
instantiable geometric class will include the specific conditions that
|
|
cause an instance of that class to be classified as not simple.
|
|
|
|
This function is the same as the C++ method OGRGeometry::IsSimple()
|
|
method.
|
|
|
|
If OGR is built without the GEOS library, this function will always
|
|
return FALSE.
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hGeom: The Geometry to test.
|
|
|
|
TRUE if object is simple, otherwise FALSE.
|
|
"""
|
|
return _ogr.Geometry_IsSimple(self, *args)
|
|
|
|
|
|
def IsRing(self, *args):
|
|
"""
|
|
IsRing(Geometry self) -> bool
|
|
|
|
int OGR_G_IsRing(OGRGeometryH hGeom)
|
|
|
|
Test if the geometry is a ring.
|
|
|
|
This function is the same as the C++ method OGRGeometry::IsRing().
|
|
|
|
This function is built on the GEOS library, check it for the
|
|
definition of the geometry operation. If OGR is built without the GEOS
|
|
library, this function will always return FALSE.
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hGeom: The Geometry to test.
|
|
|
|
TRUE if the geometry has no points, otherwise FALSE.
|
|
"""
|
|
return _ogr.Geometry_IsRing(self, *args)
|
|
|
|
|
|
def Intersects(self, *args):
|
|
"""
|
|
Intersects(Geometry self, Geometry other) -> bool
|
|
|
|
int OGR_G_Intersects(OGRGeometryH
|
|
hGeom, OGRGeometryH hOtherGeom)
|
|
|
|
Do these features intersect?
|
|
|
|
Determines whether two geometries intersect. If GEOS is enabled, then
|
|
this is done in rigorous fashion otherwise TRUE is returned if the
|
|
envelopes (bounding boxes) of the two geometries overlap.
|
|
|
|
This function is the same as the CPP method OGRGeometry::Intersects.
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hGeom: handle on the first geometry.
|
|
|
|
hOtherGeom: handle on the other geometry to test against.
|
|
|
|
TRUE if the geometries intersect, otherwise FALSE.
|
|
"""
|
|
return _ogr.Geometry_Intersects(self, *args)
|
|
|
|
|
|
def Intersect(self, *args):
|
|
"""Intersect(Geometry self, Geometry other) -> bool"""
|
|
return _ogr.Geometry_Intersect(self, *args)
|
|
|
|
|
|
def Equals(self, *args):
|
|
"""
|
|
Equals(Geometry self, Geometry other) -> bool
|
|
|
|
int OGR_G_Equals(OGRGeometryH hGeom,
|
|
OGRGeometryH hOther)
|
|
|
|
Returns TRUE if two geometries are equivalent.
|
|
|
|
This operation implements the SQL/MM ST_OrderingEquals() operation.
|
|
|
|
The comparison is done in a structural way, that is to say that the
|
|
geometry types must be identical, as well as the number and ordering
|
|
of sub-geometries and vertices. Or equivalently, two geometries are
|
|
considered equal by this method if their WKT/WKB representation is
|
|
equal. Note: this must be distinguished for equality in a spatial way
|
|
(which is the purpose of the ST_Equals() operation).
|
|
|
|
This function is the same as the CPP method OGRGeometry::Equals()
|
|
method.
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hGeom: handle on the first geometry.
|
|
|
|
hOther: handle on the other geometry to test against.
|
|
|
|
TRUE if equivalent or FALSE otherwise.
|
|
"""
|
|
return _ogr.Geometry_Equals(self, *args)
|
|
|
|
|
|
def Equal(self, *args):
|
|
"""Equal(Geometry self, Geometry other) -> bool"""
|
|
return _ogr.Geometry_Equal(self, *args)
|
|
|
|
|
|
def Disjoint(self, *args):
|
|
"""
|
|
Disjoint(Geometry self, Geometry other) -> bool
|
|
|
|
int OGR_G_Disjoint(OGRGeometryH
|
|
hThis, OGRGeometryH hOther)
|
|
|
|
Test for disjointness.
|
|
|
|
Tests if this geometry and the other geometry are disjoint.
|
|
|
|
Geometry validity is not checked. In case you are unsure of the
|
|
validity of the input geometries, call IsValid() before, otherwise the
|
|
result might be wrong.
|
|
|
|
This function is the same as the C++ method OGRGeometry::Disjoint().
|
|
|
|
This function is built on the GEOS library, check it for the
|
|
definition of the geometry operation. If OGR is built without the GEOS
|
|
library, this function will always fail, issuing a CPLE_NotSupported
|
|
error.
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hThis: the geometry to compare.
|
|
|
|
hOther: the other geometry to compare.
|
|
|
|
TRUE if they are disjoint, otherwise FALSE.
|
|
"""
|
|
return _ogr.Geometry_Disjoint(self, *args)
|
|
|
|
|
|
def Touches(self, *args):
|
|
"""
|
|
Touches(Geometry self, Geometry other) -> bool
|
|
|
|
int OGR_G_Touches(OGRGeometryH hThis,
|
|
OGRGeometryH hOther)
|
|
|
|
Test for touching.
|
|
|
|
Tests if this geometry and the other geometry are touching.
|
|
|
|
Geometry validity is not checked. In case you are unsure of the
|
|
validity of the input geometries, call IsValid() before, otherwise the
|
|
result might be wrong.
|
|
|
|
This function is the same as the C++ method OGRGeometry::Touches().
|
|
|
|
This function is built on the GEOS library, check it for the
|
|
definition of the geometry operation. If OGR is built without the GEOS
|
|
library, this function will always fail, issuing a CPLE_NotSupported
|
|
error.
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hThis: the geometry to compare.
|
|
|
|
hOther: the other geometry to compare.
|
|
|
|
TRUE if they are touching, otherwise FALSE.
|
|
"""
|
|
return _ogr.Geometry_Touches(self, *args)
|
|
|
|
|
|
def Crosses(self, *args):
|
|
"""
|
|
Crosses(Geometry self, Geometry other) -> bool
|
|
|
|
int OGR_G_Crosses(OGRGeometryH hThis,
|
|
OGRGeometryH hOther)
|
|
|
|
Test for crossing.
|
|
|
|
Tests if this geometry and the other geometry are crossing.
|
|
|
|
Geometry validity is not checked. In case you are unsure of the
|
|
validity of the input geometries, call IsValid() before, otherwise the
|
|
result might be wrong.
|
|
|
|
This function is the same as the C++ method OGRGeometry::Crosses().
|
|
|
|
This function is built on the GEOS library, check it for the
|
|
definition of the geometry operation. If OGR is built without the GEOS
|
|
library, this function will always fail, issuing a CPLE_NotSupported
|
|
error.
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hThis: the geometry to compare.
|
|
|
|
hOther: the other geometry to compare.
|
|
|
|
TRUE if they are crossing, otherwise FALSE.
|
|
"""
|
|
return _ogr.Geometry_Crosses(self, *args)
|
|
|
|
|
|
def Within(self, *args):
|
|
"""
|
|
Within(Geometry self, Geometry other) -> bool
|
|
|
|
int OGR_G_Within(OGRGeometryH hThis,
|
|
OGRGeometryH hOther)
|
|
|
|
Test for containment.
|
|
|
|
Tests if this geometry is within the other geometry.
|
|
|
|
Geometry validity is not checked. In case you are unsure of the
|
|
validity of the input geometries, call IsValid() before, otherwise the
|
|
result might be wrong.
|
|
|
|
This function is the same as the C++ method OGRGeometry::Within().
|
|
|
|
This function is built on the GEOS library, check it for the
|
|
definition of the geometry operation. If OGR is built without the GEOS
|
|
library, this function will always fail, issuing a CPLE_NotSupported
|
|
error.
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hThis: the geometry to compare.
|
|
|
|
hOther: the other geometry to compare.
|
|
|
|
TRUE if hThis is within hOther, otherwise FALSE.
|
|
"""
|
|
return _ogr.Geometry_Within(self, *args)
|
|
|
|
|
|
def Contains(self, *args):
|
|
"""
|
|
Contains(Geometry self, Geometry other) -> bool
|
|
|
|
int OGR_G_Contains(OGRGeometryH
|
|
hThis, OGRGeometryH hOther)
|
|
|
|
Test for containment.
|
|
|
|
Tests if this geometry contains the other geometry.
|
|
|
|
Geometry validity is not checked. In case you are unsure of the
|
|
validity of the input geometries, call IsValid() before, otherwise the
|
|
result might be wrong.
|
|
|
|
This function is the same as the C++ method OGRGeometry::Contains().
|
|
|
|
This function is built on the GEOS library, check it for the
|
|
definition of the geometry operation. If OGR is built without the GEOS
|
|
library, this function will always fail, issuing a CPLE_NotSupported
|
|
error.
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hThis: the geometry to compare.
|
|
|
|
hOther: the other geometry to compare.
|
|
|
|
TRUE if hThis contains hOther geometry, otherwise FALSE.
|
|
"""
|
|
return _ogr.Geometry_Contains(self, *args)
|
|
|
|
|
|
def Overlaps(self, *args):
|
|
"""
|
|
Overlaps(Geometry self, Geometry other) -> bool
|
|
|
|
int OGR_G_Overlaps(OGRGeometryH
|
|
hThis, OGRGeometryH hOther)
|
|
|
|
Test for overlap.
|
|
|
|
Tests if this geometry and the other geometry overlap, that is their
|
|
intersection has a non-zero area.
|
|
|
|
Geometry validity is not checked. In case you are unsure of the
|
|
validity of the input geometries, call IsValid() before, otherwise the
|
|
result might be wrong.
|
|
|
|
This function is the same as the C++ method OGRGeometry::Overlaps().
|
|
|
|
This function is built on the GEOS library, check it for the
|
|
definition of the geometry operation. If OGR is built without the GEOS
|
|
library, this function will always fail, issuing a CPLE_NotSupported
|
|
error.
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hThis: the geometry to compare.
|
|
|
|
hOther: the other geometry to compare.
|
|
|
|
TRUE if they are overlapping, otherwise FALSE.
|
|
"""
|
|
return _ogr.Geometry_Overlaps(self, *args)
|
|
|
|
|
|
def TransformTo(self, *args):
|
|
"""
|
|
TransformTo(Geometry self, SpatialReference reference) -> OGRErr
|
|
|
|
OGRErr
|
|
OGR_G_TransformTo(OGRGeometryH hGeom, OGRSpatialReferenceH hSRS)
|
|
|
|
Transform geometry to new spatial reference system.
|
|
|
|
This function will transform the coordinates of a geometry from their
|
|
current spatial reference system to a new target spatial reference
|
|
system. Normally this means reprojecting the vectors, but it could
|
|
include datum shifts, and changes of units.
|
|
|
|
This function will only work if the geometry already has an assigned
|
|
spatial reference system, and if it is transformable to the target
|
|
coordinate system.
|
|
|
|
Because this function requires internal creation and initialization of
|
|
an OGRCoordinateTransformation object it is significantly more
|
|
expensive to use this function to transform many geometries than it is
|
|
to create the OGRCoordinateTransformation in advance, and call
|
|
transform() with that transformation. This function exists primarily
|
|
for convenience when only transforming a single geometry.
|
|
|
|
This function is the same as the CPP method OGRGeometry::transformTo.
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hGeom: handle on the geometry to apply the transform to.
|
|
|
|
hSRS: handle on the spatial reference system to apply.
|
|
|
|
OGRERR_NONE on success, or an error code.
|
|
"""
|
|
return _ogr.Geometry_TransformTo(self, *args)
|
|
|
|
|
|
def GetSpatialReference(self, *args):
|
|
"""
|
|
GetSpatialReference(Geometry self) -> SpatialReference
|
|
|
|
OGRSpatialReferenceH
|
|
OGR_G_GetSpatialReference(OGRGeometryH hGeom)
|
|
|
|
Returns spatial reference system for geometry.
|
|
|
|
This function relates to the SFCOM IGeometry::get_SpatialReference()
|
|
method.
|
|
|
|
This function is the same as the CPP method
|
|
OGRGeometry::getSpatialReference().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hGeom: handle on the geometry to get spatial reference from.
|
|
|
|
a reference to the spatial reference geometry.
|
|
"""
|
|
return _ogr.Geometry_GetSpatialReference(self, *args)
|
|
|
|
|
|
def AssignSpatialReference(self, *args):
|
|
"""
|
|
AssignSpatialReference(Geometry self, SpatialReference reference)
|
|
|
|
void
|
|
OGR_G_AssignSpatialReference(OGRGeometryH hGeom, OGRSpatialReferenceH
|
|
hSRS)
|
|
|
|
Assign spatial reference to this object.
|
|
|
|
Any existing spatial reference is replaced, but under no circumstances
|
|
does this result in the object being reprojected. It is just changing
|
|
the interpretation of the existing geometry. Note that assigning a
|
|
spatial reference increments the reference count on the
|
|
OGRSpatialReference, but does not copy it.
|
|
|
|
Starting with GDAL 2.3, this will also assign the spatial reference to
|
|
potential sub-geometries of the geometry ( OGRGeometryCollection,
|
|
OGRCurvePolygon/OGRPolygon, OGRCompoundCurve, OGRPolyhedralSurface and
|
|
their derived classes).
|
|
|
|
This is similar to the SFCOM IGeometry::put_SpatialReference() method.
|
|
|
|
This function is the same as the CPP method
|
|
OGRGeometry::assignSpatialReference.
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hGeom: handle on the geometry to apply the new spatial reference
|
|
system.
|
|
|
|
hSRS: handle on the new spatial reference system to apply.
|
|
"""
|
|
return _ogr.Geometry_AssignSpatialReference(self, *args)
|
|
|
|
|
|
def CloseRings(self, *args):
|
|
"""
|
|
CloseRings(Geometry self)
|
|
|
|
void OGR_G_CloseRings(OGRGeometryH
|
|
hGeom)
|
|
|
|
Force rings to be closed.
|
|
|
|
If this geometry, or any contained geometries has polygon rings that
|
|
are not closed, they will be closed by adding the starting point at
|
|
the end.
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hGeom: handle to the geometry.
|
|
"""
|
|
return _ogr.Geometry_CloseRings(self, *args)
|
|
|
|
|
|
def FlattenTo2D(self, *args):
|
|
"""
|
|
FlattenTo2D(Geometry self)
|
|
|
|
void
|
|
OGR_G_FlattenTo2D(OGRGeometryH hGeom)
|
|
|
|
Convert geometry to strictly 2D.
|
|
|
|
In a sense this converts all Z coordinates to 0.0.
|
|
|
|
This function is the same as the CPP method
|
|
OGRGeometry::flattenTo2D().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hGeom: handle on the geometry to convert.
|
|
"""
|
|
return _ogr.Geometry_FlattenTo2D(self, *args)
|
|
|
|
|
|
def Segmentize(self, *args):
|
|
"""
|
|
Segmentize(Geometry self, double dfMaxLength)
|
|
|
|
void OGR_G_Segmentize(OGRGeometryH
|
|
hGeom, double dfMaxLength)
|
|
|
|
Modify the geometry such it has no segment longer then the given
|
|
distance.
|
|
|
|
Interpolated points will have Z and M values (if needed) set to 0.
|
|
Distance computation is performed in 2d only.
|
|
|
|
This function is the same as the CPP method OGRGeometry::segmentize().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hGeom: handle on the geometry to segmentize
|
|
|
|
dfMaxLength: the maximum distance between 2 points after
|
|
segmentization
|
|
"""
|
|
return _ogr.Geometry_Segmentize(self, *args)
|
|
|
|
|
|
def GetEnvelope(self, *args):
|
|
"""
|
|
GetEnvelope(Geometry self)
|
|
|
|
void
|
|
OGR_G_GetEnvelope(OGRGeometryH hGeom, OGREnvelope *psEnvelope)
|
|
|
|
Computes and returns the bounding envelope for this geometry in the
|
|
passed psEnvelope structure.
|
|
|
|
This function is the same as the CPP method
|
|
OGRGeometry::getEnvelope().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hGeom: handle of the geometry to get envelope from.
|
|
|
|
psEnvelope: the structure in which to place the results.
|
|
"""
|
|
return _ogr.Geometry_GetEnvelope(self, *args)
|
|
|
|
|
|
def GetEnvelope3D(self, *args):
|
|
"""
|
|
GetEnvelope3D(Geometry self)
|
|
|
|
void
|
|
OGR_G_GetEnvelope3D(OGRGeometryH hGeom, OGREnvelope3D *psEnvelope)
|
|
|
|
Computes and returns the bounding envelope (3D) for this geometry in
|
|
the passed psEnvelope structure.
|
|
|
|
This function is the same as the CPP method
|
|
OGRGeometry::getEnvelope().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hGeom: handle of the geometry to get envelope from.
|
|
|
|
psEnvelope: the structure in which to place the results.
|
|
|
|
OGR 1.9.0
|
|
"""
|
|
return _ogr.Geometry_GetEnvelope3D(self, *args)
|
|
|
|
|
|
def Centroid(self, *args):
|
|
"""
|
|
Centroid(Geometry self) -> Geometry
|
|
|
|
int OGR_G_Centroid(OGRGeometryH
|
|
hGeom, OGRGeometryH hCentroidPoint)
|
|
|
|
Compute the geometry centroid.
|
|
|
|
The centroid location is applied to the passed in OGRPoint object. The
|
|
centroid is not necessarily within the geometry.
|
|
|
|
This method relates to the SFCOM ISurface::get_Centroid() method
|
|
however the current implementation based on GEOS can operate on other
|
|
geometry types such as multipoint, linestring, geometrycollection such
|
|
as multipolygons. OGC SF SQL 1.1 defines the operation for surfaces
|
|
(polygons). SQL/MM-Part 3 defines the operation for surfaces and
|
|
multisurfaces (multipolygons).
|
|
|
|
This function is the same as the C++ method OGRGeometry::Centroid().
|
|
|
|
This function is built on the GEOS library, check it for the
|
|
definition of the geometry operation. If OGR is built without the GEOS
|
|
library, this function will always fail, issuing a CPLE_NotSupported
|
|
error.
|
|
|
|
OGRERR_NONE on success or OGRERR_FAILURE on error.
|
|
"""
|
|
return _ogr.Geometry_Centroid(self, *args)
|
|
|
|
|
|
def PointOnSurface(self, *args):
|
|
"""
|
|
PointOnSurface(Geometry self) -> Geometry
|
|
|
|
OGRGeometryH
|
|
OGR_G_PointOnSurface(OGRGeometryH hGeom)
|
|
|
|
Returns a point guaranteed to lie on the surface.
|
|
|
|
This method relates to the SFCOM ISurface::get_PointOnSurface() method
|
|
however the current implementation based on GEOS can operate on other
|
|
geometry types than the types that are supported by SQL/MM-Part 3 :
|
|
surfaces (polygons) and multisurfaces (multipolygons).
|
|
|
|
This method is built on the GEOS library, check it for the definition
|
|
of the geometry operation. If OGR is built without the GEOS library,
|
|
this method will always fail, issuing a CPLE_NotSupported error.
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hGeom: the geometry to operate on.
|
|
|
|
a point guaranteed to lie on the surface or NULL if an error occurred.
|
|
|
|
OGR 1.10
|
|
"""
|
|
return _ogr.Geometry_PointOnSurface(self, *args)
|
|
|
|
|
|
def WkbSize(self, *args):
|
|
"""
|
|
WkbSize(Geometry self) -> size_t
|
|
|
|
int OGR_G_WkbSize(OGRGeometryH hGeom)
|
|
|
|
Returns size of related binary representation.
|
|
|
|
This function returns the exact number of bytes required to hold the
|
|
well known binary representation of this geometry object. Its
|
|
computation may be slightly expensive for complex geometries.
|
|
|
|
This function relates to the SFCOM IWks::WkbSize() method.
|
|
|
|
This function is the same as the CPP method OGRGeometry::WkbSize().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hGeom: handle on the geometry to get the binary size from.
|
|
|
|
size of binary representation in bytes.
|
|
"""
|
|
return _ogr.Geometry_WkbSize(self, *args)
|
|
|
|
|
|
def GetCoordinateDimension(self, *args):
|
|
"""
|
|
GetCoordinateDimension(Geometry self) -> int
|
|
|
|
int
|
|
OGR_G_GetCoordinateDimension(OGRGeometryH hGeom)
|
|
|
|
Get the dimension of the coordinates in this geometry.
|
|
|
|
This function is the same as the CPP method
|
|
OGRGeometry::getCoordinateDimension().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hGeom: handle on the geometry to get the dimension of the coordinates
|
|
from.
|
|
|
|
Deprecated use OGR_G_CoordinateDimension(), OGR_G_Is3D(), or
|
|
OGR_G_IsMeasured().
|
|
|
|
this will return 2 or 3.
|
|
"""
|
|
return _ogr.Geometry_GetCoordinateDimension(self, *args)
|
|
|
|
|
|
def CoordinateDimension(self, *args):
|
|
"""
|
|
CoordinateDimension(Geometry self) -> int
|
|
|
|
int
|
|
OGR_G_CoordinateDimension(OGRGeometryH hGeom)
|
|
|
|
Get the dimension of the coordinates in this geometry.
|
|
|
|
This function is the same as the CPP method
|
|
OGRGeometry::CoordinateDimension().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hGeom: handle on the geometry to get the dimension of the coordinates
|
|
from.
|
|
|
|
this will return 2 for XY, 3 for XYZ and XYM, and 4 for XYZM data.
|
|
|
|
GDAL 2.1
|
|
"""
|
|
return _ogr.Geometry_CoordinateDimension(self, *args)
|
|
|
|
|
|
def Is3D(self, *args):
|
|
"""
|
|
Is3D(Geometry self) -> int
|
|
|
|
int OGR_G_Is3D(OGRGeometryH hGeom)
|
|
|
|
See whether this geometry has Z coordinates.
|
|
|
|
This function is the same as the CPP method OGRGeometry::Is3D().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hGeom: handle on the geometry to check whether it has Z coordinates.
|
|
|
|
TRUE if the geometry has Z coordinates.
|
|
|
|
GDAL 2.1
|
|
"""
|
|
return _ogr.Geometry_Is3D(self, *args)
|
|
|
|
|
|
def IsMeasured(self, *args):
|
|
"""
|
|
IsMeasured(Geometry self) -> int
|
|
|
|
int OGR_G_IsMeasured(OGRGeometryH
|
|
hGeom)
|
|
|
|
See whether this geometry is measured.
|
|
|
|
This function is the same as the CPP method OGRGeometry::IsMeasured().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hGeom: handle on the geometry to check whether it is measured.
|
|
|
|
TRUE if the geometry has M coordinates.
|
|
|
|
GDAL 2.1
|
|
"""
|
|
return _ogr.Geometry_IsMeasured(self, *args)
|
|
|
|
|
|
def SetCoordinateDimension(self, *args):
|
|
"""
|
|
SetCoordinateDimension(Geometry self, int dimension)
|
|
|
|
void
|
|
OGR_G_SetCoordinateDimension(OGRGeometryH hGeom, int nNewDimension)
|
|
|
|
Set the coordinate dimension.
|
|
|
|
This method sets the explicit coordinate dimension. Setting the
|
|
coordinate dimension of a geometry to 2 should zero out any existing Z
|
|
values. Setting the dimension of a geometry collection, a compound
|
|
curve, a polygon, etc. will affect the children geometries. This will
|
|
also remove the M dimension if present before this call.
|
|
|
|
Deprecated use OGR_G_Set3D() or OGR_G_SetMeasured().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hGeom: handle on the geometry to set the dimension of the
|
|
coordinates.
|
|
|
|
nNewDimension: New coordinate dimension value, either 2 or 3.
|
|
"""
|
|
return _ogr.Geometry_SetCoordinateDimension(self, *args)
|
|
|
|
|
|
def Set3D(self, *args):
|
|
"""
|
|
Set3D(Geometry self, int b3D)
|
|
|
|
void OGR_G_Set3D(OGRGeometryH hGeom,
|
|
int bIs3D)
|
|
|
|
Add or remove the Z coordinate dimension.
|
|
|
|
This method adds or removes the explicit Z coordinate dimension.
|
|
Removing the Z coordinate dimension of a geometry will remove any
|
|
existing Z values. Adding the Z dimension to a geometry collection, a
|
|
compound curve, a polygon, etc. will affect the children geometries.
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hGeom: handle on the geometry to set or unset the Z dimension.
|
|
|
|
bIs3D: Should the geometry have a Z dimension, either TRUE or FALSE.
|
|
|
|
GDAL 2.1
|
|
"""
|
|
return _ogr.Geometry_Set3D(self, *args)
|
|
|
|
|
|
def SetMeasured(self, *args):
|
|
"""
|
|
SetMeasured(Geometry self, int bMeasured)
|
|
|
|
void
|
|
OGR_G_SetMeasured(OGRGeometryH hGeom, int bIsMeasured)
|
|
|
|
Add or remove the M coordinate dimension.
|
|
|
|
This method adds or removes the explicit M coordinate dimension.
|
|
Removing the M coordinate dimension of a geometry will remove any
|
|
existing M values. Adding the M dimension to a geometry collection, a
|
|
compound curve, a polygon, etc. will affect the children geometries.
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hGeom: handle on the geometry to set or unset the M dimension.
|
|
|
|
bIsMeasured: Should the geometry have a M dimension, either TRUE or
|
|
FALSE.
|
|
|
|
GDAL 2.1
|
|
"""
|
|
return _ogr.Geometry_SetMeasured(self, *args)
|
|
|
|
|
|
def GetDimension(self, *args):
|
|
"""
|
|
GetDimension(Geometry self) -> int
|
|
|
|
int
|
|
OGR_G_GetDimension(OGRGeometryH hGeom)
|
|
|
|
Get the dimension of this geometry.
|
|
|
|
This function corresponds to the SFCOM IGeometry::GetDimension()
|
|
method. It indicates the dimension of the geometry, but does not
|
|
indicate the dimension of the underlying space (as indicated by
|
|
OGR_G_GetCoordinateDimension() function).
|
|
|
|
This function is the same as the CPP method
|
|
OGRGeometry::getDimension().
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hGeom: handle on the geometry to get the dimension from.
|
|
|
|
0 for points, 1 for lines and 2 for surfaces.
|
|
"""
|
|
return _ogr.Geometry_GetDimension(self, *args)
|
|
|
|
|
|
def HasCurveGeometry(self, *args):
|
|
"""HasCurveGeometry(Geometry self, int bLookForCircular=False) -> int"""
|
|
return _ogr.Geometry_HasCurveGeometry(self, *args)
|
|
|
|
|
|
def GetLinearGeometry(self, *args, **kwargs):
|
|
"""GetLinearGeometry(Geometry self, double dfMaxAngleStepSizeDegrees=0.0, char ** options=None) -> Geometry"""
|
|
return _ogr.Geometry_GetLinearGeometry(self, *args, **kwargs)
|
|
|
|
|
|
def GetCurveGeometry(self, *args, **kwargs):
|
|
"""GetCurveGeometry(Geometry self, char ** options=None) -> Geometry"""
|
|
return _ogr.Geometry_GetCurveGeometry(self, *args, **kwargs)
|
|
|
|
|
|
def Value(self, *args):
|
|
"""Value(Geometry self, double dfDistance) -> Geometry"""
|
|
return _ogr.Geometry_Value(self, *args)
|
|
|
|
|
|
def Transform(self, *args):
|
|
"""
|
|
Transform(Geometry self, CoordinateTransformation trans) -> OGRErr
|
|
Transform(Geometry self, GeomTransformer transformer) -> Geometry
|
|
|
|
OGRErr OGR_G_Transform(OGRGeometryH
|
|
hGeom, OGRCoordinateTransformationH hTransform)
|
|
|
|
Apply arbitrary coordinate transformation to geometry.
|
|
|
|
This function will transform the coordinates of a geometry from their
|
|
current spatial reference system to a new target spatial reference
|
|
system. Normally this means reprojecting the vectors, but it could
|
|
include datum shifts, and changes of units.
|
|
|
|
Note that this function does not require that the geometry already
|
|
have a spatial reference system. It will be assumed that they can be
|
|
treated as having the source spatial reference system of the
|
|
OGRCoordinateTransformation object, and the actual SRS of the geometry
|
|
will be ignored. On successful completion the output
|
|
OGRSpatialReference of the OGRCoordinateTransformation will be
|
|
assigned to the geometry.
|
|
|
|
This function is the same as the CPP method OGRGeometry::transform.
|
|
|
|
Parameters:
|
|
-----------
|
|
|
|
hGeom: handle on the geometry to apply the transform to.
|
|
|
|
hTransform: handle on the transformation to apply.
|
|
|
|
OGRERR_NONE on success or an error code.
|
|
"""
|
|
return _ogr.Geometry_Transform(self, *args)
|
|
|
|
|
|
def CreatePreparedGeometry(self, *args):
|
|
"""CreatePreparedGeometry(Geometry self) -> PreparedGeometry"""
|
|
return _ogr.Geometry_CreatePreparedGeometry(self, *args)
|
|
|
|
|
|
def Destroy(self):
|
|
self.__swig_destroy__(self)
|
|
self.__del__()
|
|
self.thisown = 0
|
|
|
|
def __str__(self):
|
|
return self.ExportToWkt()
|
|
|
|
def __copy__(self):
|
|
return self.Clone()
|
|
|
|
def __deepcopy__(self, memo):
|
|
g = self.Clone()
|
|
srs = self.GetSpatialReference()
|
|
if srs:
|
|
g.AssignSpatialReference(srs.Clone())
|
|
return g
|
|
|
|
def __reduce__(self):
|
|
return (self.__class__, (), self.ExportToWkb())
|
|
|
|
def __setstate__(self, state):
|
|
result = CreateGeometryFromWkb(state)
|
|
self.this = result.this
|
|
|
|
def __iter__(self):
|
|
for i in range(self.GetGeometryCount()):
|
|
yield self.GetGeometryRef(i)
|
|
|
|
|
|
Geometry_swigregister = _ogr.Geometry_swigregister
|
|
Geometry_swigregister(Geometry)
|
|
|
|
class PreparedGeometry(_object):
|
|
"""Proxy of C++ OGRPreparedGeometryShadow class."""
|
|
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, PreparedGeometry, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, PreparedGeometry, name)
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined")
|
|
__repr__ = _swig_repr
|
|
__swig_destroy__ = _ogr.delete_PreparedGeometry
|
|
__del__ = lambda self: None
|
|
|
|
def Intersects(self, *args):
|
|
"""Intersects(PreparedGeometry self, Geometry otherGeom) -> bool"""
|
|
return _ogr.PreparedGeometry_Intersects(self, *args)
|
|
|
|
|
|
def Contains(self, *args):
|
|
"""Contains(PreparedGeometry self, Geometry otherGeom) -> bool"""
|
|
return _ogr.PreparedGeometry_Contains(self, *args)
|
|
|
|
PreparedGeometry_swigregister = _ogr.PreparedGeometry_swigregister
|
|
PreparedGeometry_swigregister(PreparedGeometry)
|
|
|
|
class GeomTransformer(_object):
|
|
"""Proxy of C++ OGRGeomTransformerShadow class."""
|
|
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, GeomTransformer, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, GeomTransformer, name)
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, *args):
|
|
"""__init__(OGRGeomTransformerShadow self, CoordinateTransformation ct, char ** options=None) -> GeomTransformer"""
|
|
this = _ogr.new_GeomTransformer(*args)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
__swig_destroy__ = _ogr.delete_GeomTransformer
|
|
__del__ = lambda self: None
|
|
|
|
def Transform(self, *args):
|
|
"""Transform(GeomTransformer self, Geometry src_geom) -> Geometry"""
|
|
return _ogr.GeomTransformer_Transform(self, *args)
|
|
|
|
GeomTransformer_swigregister = _ogr.GeomTransformer_swigregister
|
|
GeomTransformer_swigregister(GeomTransformer)
|
|
|
|
class FieldDomain(_object):
|
|
"""Proxy of C++ OGRFieldDomainShadow class."""
|
|
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, FieldDomain, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, FieldDomain, name)
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined")
|
|
__repr__ = _swig_repr
|
|
__swig_destroy__ = _ogr.delete_FieldDomain
|
|
__del__ = lambda self: None
|
|
|
|
def GetName(self, *args):
|
|
"""GetName(FieldDomain self) -> char const *"""
|
|
return _ogr.FieldDomain_GetName(self, *args)
|
|
|
|
|
|
def GetDescription(self, *args):
|
|
"""GetDescription(FieldDomain self) -> char const *"""
|
|
return _ogr.FieldDomain_GetDescription(self, *args)
|
|
|
|
|
|
def GetFieldType(self, *args):
|
|
"""GetFieldType(FieldDomain self) -> OGRFieldType"""
|
|
return _ogr.FieldDomain_GetFieldType(self, *args)
|
|
|
|
|
|
def GetFieldSubType(self, *args):
|
|
"""GetFieldSubType(FieldDomain self) -> OGRFieldSubType"""
|
|
return _ogr.FieldDomain_GetFieldSubType(self, *args)
|
|
|
|
|
|
def GetDomainType(self, *args):
|
|
"""GetDomainType(FieldDomain self) -> OGRFieldDomainType"""
|
|
return _ogr.FieldDomain_GetDomainType(self, *args)
|
|
|
|
|
|
def GetSplitPolicy(self, *args):
|
|
"""GetSplitPolicy(FieldDomain self) -> OGRFieldDomainSplitPolicy"""
|
|
return _ogr.FieldDomain_GetSplitPolicy(self, *args)
|
|
|
|
|
|
def SetSplitPolicy(self, *args):
|
|
"""SetSplitPolicy(FieldDomain self, OGRFieldDomainSplitPolicy policy)"""
|
|
return _ogr.FieldDomain_SetSplitPolicy(self, *args)
|
|
|
|
|
|
def GetMergePolicy(self, *args):
|
|
"""GetMergePolicy(FieldDomain self) -> OGRFieldDomainMergePolicy"""
|
|
return _ogr.FieldDomain_GetMergePolicy(self, *args)
|
|
|
|
|
|
def SetMergePolicy(self, *args):
|
|
"""SetMergePolicy(FieldDomain self, OGRFieldDomainMergePolicy policy)"""
|
|
return _ogr.FieldDomain_SetMergePolicy(self, *args)
|
|
|
|
|
|
def GetEnumeration(self, *args):
|
|
"""GetEnumeration(FieldDomain self) -> OGRCodedValue const *"""
|
|
return _ogr.FieldDomain_GetEnumeration(self, *args)
|
|
|
|
|
|
def GetMinAsDouble(self, *args):
|
|
"""GetMinAsDouble(FieldDomain self) -> double"""
|
|
return _ogr.FieldDomain_GetMinAsDouble(self, *args)
|
|
|
|
|
|
def IsMinInclusive(self, *args):
|
|
"""IsMinInclusive(FieldDomain self) -> bool"""
|
|
return _ogr.FieldDomain_IsMinInclusive(self, *args)
|
|
|
|
|
|
def GetMaxAsDouble(self, *args):
|
|
"""GetMaxAsDouble(FieldDomain self) -> double"""
|
|
return _ogr.FieldDomain_GetMaxAsDouble(self, *args)
|
|
|
|
|
|
def IsMaxInclusive(self, *args):
|
|
"""IsMaxInclusive(FieldDomain self) -> bool"""
|
|
return _ogr.FieldDomain_IsMaxInclusive(self, *args)
|
|
|
|
|
|
def GetGlob(self, *args):
|
|
"""GetGlob(FieldDomain self) -> char const *"""
|
|
return _ogr.FieldDomain_GetGlob(self, *args)
|
|
|
|
FieldDomain_swigregister = _ogr.FieldDomain_swigregister
|
|
FieldDomain_swigregister(FieldDomain)
|
|
|
|
|
|
def CreateCodedFieldDomain(*args):
|
|
"""CreateCodedFieldDomain(char const * name, char const * description, OGRFieldType type, OGRFieldSubType subtype, OGRCodedValue const * enumeration) -> FieldDomain"""
|
|
return _ogr.CreateCodedFieldDomain(*args)
|
|
|
|
def CreateRangeFieldDomain(*args):
|
|
"""CreateRangeFieldDomain(char const * name, char const * description, OGRFieldType type, OGRFieldSubType subtype, double min, bool minIsInclusive, double max, double maxIsInclusive) -> FieldDomain"""
|
|
return _ogr.CreateRangeFieldDomain(*args)
|
|
|
|
def CreateGlobFieldDomain(*args):
|
|
"""CreateGlobFieldDomain(char const * name, char const * description, OGRFieldType type, OGRFieldSubType subtype, char const * glob) -> FieldDomain"""
|
|
return _ogr.CreateGlobFieldDomain(*args)
|
|
|
|
def GetDriverCount(*args):
|
|
"""GetDriverCount() -> int"""
|
|
return _ogr.GetDriverCount(*args)
|
|
|
|
def GetOpenDSCount(*args):
|
|
"""GetOpenDSCount() -> int"""
|
|
return _ogr.GetOpenDSCount(*args)
|
|
|
|
def SetGenerate_DB2_V72_BYTE_ORDER(*args):
|
|
"""SetGenerate_DB2_V72_BYTE_ORDER(int bGenerate_DB2_V72_BYTE_ORDER) -> OGRErr"""
|
|
return _ogr.SetGenerate_DB2_V72_BYTE_ORDER(*args)
|
|
|
|
def RegisterAll(*args):
|
|
"""RegisterAll()"""
|
|
return _ogr.RegisterAll(*args)
|
|
|
|
def GeometryTypeToName(*args):
|
|
"""GeometryTypeToName(OGRwkbGeometryType eType) -> char const *"""
|
|
return _ogr.GeometryTypeToName(*args)
|
|
|
|
def GetFieldTypeName(*args):
|
|
"""GetFieldTypeName(OGRFieldType type) -> char const *"""
|
|
return _ogr.GetFieldTypeName(*args)
|
|
|
|
def GetFieldSubTypeName(*args):
|
|
"""GetFieldSubTypeName(OGRFieldSubType type) -> char const *"""
|
|
return _ogr.GetFieldSubTypeName(*args)
|
|
|
|
def GT_Flatten(*args):
|
|
"""GT_Flatten(OGRwkbGeometryType eType) -> OGRwkbGeometryType"""
|
|
return _ogr.GT_Flatten(*args)
|
|
|
|
def GT_SetZ(*args):
|
|
"""GT_SetZ(OGRwkbGeometryType eType) -> OGRwkbGeometryType"""
|
|
return _ogr.GT_SetZ(*args)
|
|
|
|
def GT_SetM(*args):
|
|
"""GT_SetM(OGRwkbGeometryType eType) -> OGRwkbGeometryType"""
|
|
return _ogr.GT_SetM(*args)
|
|
|
|
def GT_SetModifier(*args):
|
|
"""GT_SetModifier(OGRwkbGeometryType eType, int bSetZ, int bSetM=False) -> OGRwkbGeometryType"""
|
|
return _ogr.GT_SetModifier(*args)
|
|
|
|
def GT_HasZ(*args):
|
|
"""GT_HasZ(OGRwkbGeometryType eType) -> int"""
|
|
return _ogr.GT_HasZ(*args)
|
|
|
|
def GT_HasM(*args):
|
|
"""GT_HasM(OGRwkbGeometryType eType) -> int"""
|
|
return _ogr.GT_HasM(*args)
|
|
|
|
def GT_IsSubClassOf(*args):
|
|
"""GT_IsSubClassOf(OGRwkbGeometryType eType, OGRwkbGeometryType eSuperType) -> int"""
|
|
return _ogr.GT_IsSubClassOf(*args)
|
|
|
|
def GT_IsCurve(*args):
|
|
"""GT_IsCurve(OGRwkbGeometryType arg1) -> int"""
|
|
return _ogr.GT_IsCurve(*args)
|
|
|
|
def GT_IsSurface(*args):
|
|
"""GT_IsSurface(OGRwkbGeometryType arg1) -> int"""
|
|
return _ogr.GT_IsSurface(*args)
|
|
|
|
def GT_IsNonLinear(*args):
|
|
"""GT_IsNonLinear(OGRwkbGeometryType arg1) -> int"""
|
|
return _ogr.GT_IsNonLinear(*args)
|
|
|
|
def GT_GetCollection(*args):
|
|
"""GT_GetCollection(OGRwkbGeometryType eType) -> OGRwkbGeometryType"""
|
|
return _ogr.GT_GetCollection(*args)
|
|
|
|
def GT_GetCurve(*args):
|
|
"""GT_GetCurve(OGRwkbGeometryType eType) -> OGRwkbGeometryType"""
|
|
return _ogr.GT_GetCurve(*args)
|
|
|
|
def GT_GetLinear(*args):
|
|
"""GT_GetLinear(OGRwkbGeometryType eType) -> OGRwkbGeometryType"""
|
|
return _ogr.GT_GetLinear(*args)
|
|
|
|
def SetNonLinearGeometriesEnabledFlag(*args):
|
|
"""SetNonLinearGeometriesEnabledFlag(int bFlag)"""
|
|
return _ogr.SetNonLinearGeometriesEnabledFlag(*args)
|
|
|
|
def GetNonLinearGeometriesEnabledFlag(*args):
|
|
"""GetNonLinearGeometriesEnabledFlag() -> int"""
|
|
return _ogr.GetNonLinearGeometriesEnabledFlag(*args)
|
|
|
|
def GetOpenDS(*args):
|
|
"""GetOpenDS(int ds_number) -> DataSource"""
|
|
return _ogr.GetOpenDS(*args)
|
|
|
|
def Open(*args, **kwargs):
|
|
"""Open(char const * utf8_path, int update=0) -> DataSource"""
|
|
return _ogr.Open(*args, **kwargs)
|
|
|
|
def OpenShared(*args, **kwargs):
|
|
"""OpenShared(char const * utf8_path, int update=0) -> DataSource"""
|
|
return _ogr.OpenShared(*args, **kwargs)
|
|
|
|
def GetDriverByName(*args):
|
|
"""GetDriverByName(char const * name) -> Driver"""
|
|
return _ogr.GetDriverByName(*args)
|
|
|
|
def GetDriver(*args):
|
|
"""GetDriver(int driver_number) -> Driver"""
|
|
return _ogr.GetDriver(*args)
|
|
|
|
def GeneralCmdLineProcessor(*args):
|
|
"""GeneralCmdLineProcessor(char ** papszArgv, int nOptions=0) -> char **"""
|
|
return _ogr.GeneralCmdLineProcessor(*args)
|
|
|
|
def TermProgress_nocb(*args, **kwargs):
|
|
"""TermProgress_nocb(double dfProgress, char const * pszMessage=None, void * pData=None) -> int"""
|
|
return _ogr.TermProgress_nocb(*args, **kwargs)
|
|
TermProgress = _ogr.TermProgress
|
|
# This file is compatible with both classic and new-style classes.
|
|
|
|
|