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