/django/contrib/gis/gdal/layer.py
Python | 212 lines | 132 code | 25 blank | 55 comment | 32 complexity | 9e612d749b966925f67e34f3253bc584 MD5 | raw file
Possible License(s): BSD-3-Clause
- # Needed ctypes routines
- from ctypes import c_double, byref
- # Other GDAL imports.
- from django.contrib.gis.gdal.base import GDALBase
- from django.contrib.gis.gdal.envelope import Envelope, OGREnvelope
- from django.contrib.gis.gdal.error import OGRException, OGRIndexError, SRSException
- from django.contrib.gis.gdal.feature import Feature
- from django.contrib.gis.gdal.field import OGRFieldTypes
- from django.contrib.gis.gdal.geomtype import OGRGeomType
- from django.contrib.gis.gdal.geometries import OGRGeometry
- from django.contrib.gis.gdal.srs import SpatialReference
- # GDAL ctypes function prototypes.
- from django.contrib.gis.gdal.prototypes import ds as capi, geom as geom_api, srs as srs_api
- # For more information, see the OGR C API source code:
- # http://www.gdal.org/ogr/ogr__api_8h.html
- #
- # The OGR_L_* routines are relevant here.
- class Layer(GDALBase):
- "A class that wraps an OGR Layer, needs to be instantiated from a DataSource object."
- #### Python 'magic' routines ####
- def __init__(self, layer_ptr, ds):
- """
- Initializes on an OGR C pointer to the Layer and the `DataSource` object
- that owns this layer. The `DataSource` object is required so that a
- reference to it is kept with this Layer. This prevents garbage
- collection of the `DataSource` while this Layer is still active.
- """
- if not layer_ptr:
- raise OGRException('Cannot create Layer, invalid pointer given')
- self.ptr = layer_ptr
- self._ds = ds
- self._ldefn = capi.get_layer_defn(self._ptr)
- # Does the Layer support random reading?
- self._random_read = self.test_capability('RandomRead')
- def __getitem__(self, index):
- "Gets the Feature at the specified index."
- if isinstance(index, (int, long)):
- # An integer index was given -- we cannot do a check based on the
- # number of features because the beginning and ending feature IDs
- # are not guaranteed to be 0 and len(layer)-1, respectively.
- if index < 0: raise OGRIndexError('Negative indices are not allowed on OGR Layers.')
- return self._make_feature(index)
- elif isinstance(index, slice):
- # A slice was given
- start, stop, stride = index.indices(self.num_feat)
- return [self._make_feature(fid) for fid in xrange(start, stop, stride)]
- else:
- raise TypeError('Integers and slices may only be used when indexing OGR Layers.')
- def __iter__(self):
- "Iterates over each Feature in the Layer."
- # ResetReading() must be called before iteration is to begin.
- capi.reset_reading(self._ptr)
- for i in xrange(self.num_feat):
- yield Feature(capi.get_next_feature(self._ptr), self._ldefn)
- def __len__(self):
- "The length is the number of features."
- return self.num_feat
- def __str__(self):
- "The string name of the layer."
- return self.name
- def _make_feature(self, feat_id):
- """
- Helper routine for __getitem__ that constructs a Feature from the given
- Feature ID. If the OGR Layer does not support random-access reading,
- then each feature of the layer will be incremented through until the
- a Feature is found matching the given feature ID.
- """
- if self._random_read:
- # If the Layer supports random reading, return.
- try:
- return Feature(capi.get_feature(self.ptr, feat_id), self._ldefn)
- except OGRException:
- pass
- else:
- # Random access isn't supported, have to increment through
- # each feature until the given feature ID is encountered.
- for feat in self:
- if feat.fid == feat_id: return feat
- # Should have returned a Feature, raise an OGRIndexError.
- raise OGRIndexError('Invalid feature id: %s.' % feat_id)
- #### Layer properties ####
- @property
- def extent(self):
- "Returns the extent (an Envelope) of this layer."
- env = OGREnvelope()
- capi.get_extent(self.ptr, byref(env), 1)
- return Envelope(env)
- @property
- def name(self):
- "Returns the name of this layer in the Data Source."
- return capi.get_fd_name(self._ldefn)
- @property
- def num_feat(self, force=1):
- "Returns the number of features in the Layer."
- return capi.get_feature_count(self.ptr, force)
- @property
- def num_fields(self):
- "Returns the number of fields in the Layer."
- return capi.get_field_count(self._ldefn)
- @property
- def geom_type(self):
- "Returns the geometry type (OGRGeomType) of the Layer."
- return OGRGeomType(capi.get_fd_geom_type(self._ldefn))
- @property
- def srs(self):
- "Returns the Spatial Reference used in this Layer."
- try:
- ptr = capi.get_layer_srs(self.ptr)
- return SpatialReference(srs_api.clone_srs(ptr))
- except SRSException:
- return None
- @property
- def fields(self):
- """
- Returns a list of string names corresponding to each of the Fields
- available in this Layer.
- """
- return [capi.get_field_name(capi.get_field_defn(self._ldefn, i))
- for i in xrange(self.num_fields) ]
-
- @property
- def field_types(self):
- """
- Returns a list of the types of fields in this Layer. For example,
- the list [OFTInteger, OFTReal, OFTString] would be returned for
- an OGR layer that had an integer, a floating-point, and string
- fields.
- """
- return [OGRFieldTypes[capi.get_field_type(capi.get_field_defn(self._ldefn, i))]
- for i in xrange(self.num_fields)]
- @property
- def field_widths(self):
- "Returns a list of the maximum field widths for the features."
- return [capi.get_field_width(capi.get_field_defn(self._ldefn, i))
- for i in xrange(self.num_fields)]
- @property
- def field_precisions(self):
- "Returns the field precisions for the features."
- return [capi.get_field_precision(capi.get_field_defn(self._ldefn, i))
- for i in xrange(self.num_fields)]
- def _get_spatial_filter(self):
- try:
- return OGRGeometry(geom_api.clone_geom(capi.get_spatial_filter(self.ptr)))
- except OGRException:
- return None
- def _set_spatial_filter(self, filter):
- if isinstance(filter, OGRGeometry):
- capi.set_spatial_filter(self.ptr, filter.ptr)
- elif isinstance(filter, (tuple, list)):
- if not len(filter) == 4:
- raise ValueError('Spatial filter list/tuple must have 4 elements.')
- # Map c_double onto params -- if a bad type is passed in it
- # will be caught here.
- xmin, ymin, xmax, ymax = map(c_double, filter)
- capi.set_spatial_filter_rect(self.ptr, xmin, ymin, xmax, ymax)
- elif filter is None:
- capi.set_spatial_filter(self.ptr, None)
- else:
- raise TypeError('Spatial filter must be either an OGRGeometry instance, a 4-tuple, or None.')
- spatial_filter = property(_get_spatial_filter, _set_spatial_filter)
- #### Layer Methods ####
- def get_fields(self, field_name):
- """
- Returns a list containing the given field name for every Feature
- in the Layer.
- """
- if not field_name in self.fields:
- raise OGRException('invalid field name: %s' % field_name)
- return [feat.get(field_name) for feat in self]
- def get_geoms(self, geos=False):
- """
- Returns a list containing the OGRGeometry for every Feature in
- the Layer.
- """
- if geos:
- from django.contrib.gis.geos import GEOSGeometry
- return [GEOSGeometry(feat.geom.wkb) for feat in self]
- else:
- return [feat.geom for feat in self]
- def test_capability(self, capability):
- """
- Returns a bool indicating whether the this Layer supports the given
- capability (a string). Valid capability strings include:
- 'RandomRead', 'SequentialWrite', 'RandomWrite', 'FastSpatialFilter',
- 'FastFeatureCount', 'FastGetExtent', 'CreateField', 'Transactions',
- 'DeleteFeature', and 'FastSetNextByIndex'.
- """
- return bool(capi.test_capability(self.ptr, capability))