webapp/django/contrib/gis/gdal/geometries.py - gerrit - Git at Google

 """
  The OGRGeometry is a wrapper for using the OGR Geometry class
  (see http://www.gdal.org/ogr/classOGRGeometry.html).  OGRGeometry
  may be instantiated when reading geometries from OGR Data Sources
  (e.g. SHP files), or when given OGC WKT (a string).

  While the 'full' API is not present yet, the API is "pythonic" unlike
  the traditional and "next-generation" OGR Python bindings.  One major
  advantage OGR Geometries have over their GEOS counterparts is support
  for spatial reference systems and their transformation.

  Example:
   >>> from django.contrib.gis.gdal import OGRGeometry, OGRGeomType, SpatialReference
   >>> wkt1, wkt2 = 'POINT(-90 30)', 'POLYGON((0 0, 5 0, 5 5, 0 5)'
   >>> pnt = OGRGeometry(wkt1)
   >>> print pnt
   POINT (-90 30)
   >>> mpnt = OGRGeometry(OGRGeomType('MultiPoint'), SpatialReference('WGS84'))
   >>> mpnt.add(wkt1)
   >>> mpnt.add(wkt1)
   >>> print mpnt
   MULTIPOINT (-90 30,-90 30)
   >>> print mpnt.srs.name
   WGS 84
   >>> print mpnt.srs.proj
   +proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs
   >>> mpnt.transform_to(SpatialReference('NAD27'))
   >>> print mpnt.proj
   +proj=longlat +ellps=clrk66 +datum=NAD27 +no_defs
   >>> print mpnt
   MULTIPOINT (-89.999930378602485 29.999797886557641,-89.999930378602485 29.999797886557641)

   The OGRGeomType class is to make it easy to specify an OGR geometry type:
   >>> from django.contrib.gis.gdal import OGRGeomType
   >>> gt1 = OGRGeomType(3) # Using an integer for the type
   >>> gt2 = OGRGeomType('Polygon') # Using a string
   >>> gt3 = OGRGeomType('POLYGON') # It's case-insensitive
   >>> print gt1 == 3, gt1 == 'Polygon' # Equivalence works w/non-OGRGeomType objects
   True
 """
 # Python library requisites.
 import re, sys
 from binascii import a2b_hex
 from ctypes import byref, string_at, c_char_p, c_double, c_ubyte, c_void_p
 from types import UnicodeType

 # Getting GDAL prerequisites
 from django.contrib.gis.gdal.envelope import Envelope, OGREnvelope
 from django.contrib.gis.gdal.error import OGRException, OGRIndexError, SRSException
 from django.contrib.gis.gdal.geomtype import OGRGeomType
 from django.contrib.gis.gdal.srs import SpatialReference, CoordTransform

 # Getting the ctypes prototype functions that interface w/the GDAL C library.
 from django.contrib.gis.gdal.prototypes.geom import *
 from django.contrib.gis.gdal.prototypes.srs import clone_srs

 # For more information, see the OGR C API source code:
 #  http://www.gdal.org/ogr/ogr__api_8h.html
 #
 # The OGR_G_* routines are relevant here.

 # Regular expressions for recognizing HEXEWKB and WKT.
 hex_regex = re.compile(r'^[0-9A-F]+$', re.I)
 wkt_regex = re.compile(r'^(?P<type>POINT|LINESTRING|LINEARRING|POLYGON|MULTIPOINT|MULTILINESTRING|MULTIPOLYGON|GEOMETRYCOLLECTION)[ACEGIMLONPSRUTY\d,\.\-\(\) ]+$', re.I)
 json_regex = re.compile(r'^\{[\s\w,\-\.\"\'\:\[\]]+\}$')

 #### OGRGeometry Class ####
 class OGRGeometry(object):
     "Generally encapsulates an OGR geometry."

     def __init__(self, geom_input, srs=None):
         "Initializes Geometry on either WKT or an OGR pointer as input."

         self._ptr = c_void_p(None) # Initially NULL
         str_instance = isinstance(geom_input, basestring)

         # If HEX, unpack input to to a binary buffer.
         if str_instance and hex_regex.match(geom_input):
             geom_input = buffer(a2b_hex(geom_input.upper()))
             str_instance = False

         # Constructing the geometry,
         if str_instance:
             # Checking if unicode
             if isinstance(geom_input, UnicodeType):
                 # Encoding to ASCII, WKT or HEX doesn't need any more.
                 geo_input = geo_input.encode('ascii')

             wkt_m = wkt_regex.match(geom_input)
             json_m = json_regex.match(geom_input)
             if wkt_m:
                 if wkt_m.group('type').upper() == 'LINEARRING':
                     # OGR_G_CreateFromWkt doesn't work with LINEARRING WKT.
                     #  See http://trac.osgeo.org/gdal/ticket/1992.
                     g = create_geom(OGRGeomType(wkt_m.group('type')).num)
                     import_wkt(g, byref(c_char_p(geom_input)))
                 else:
                     g = from_wkt(byref(c_char_p(geom_input)), None, byref(c_void_p()))
             elif json_m:
                 if GEOJSON:
                     g = from_json(geom_input)
                 else:
                     raise NotImplementedError('GeoJSON input only supported on GDAL 1.5+.')
             else:
                 # Seeing if the input is a valid short-hand string
                 # (e.g., 'Point', 'POLYGON').
                 ogr_t = OGRGeomType(geom_input)
                 g = create_geom(OGRGeomType(geom_input).num)
         elif isinstance(geom_input, buffer):
             # WKB was passed in
             g = from_wkb(str(geom_input), None, byref(c_void_p()), len(geom_input))
         elif isinstance(geom_input, OGRGeomType):
             # OGRGeomType was passed in, an empty geometry will be created.
             g = create_geom(geom_input.num)
         elif isinstance(geom_input, c_void_p):
             # OGR pointer (c_void_p) was the input.
             g = geom_input
         else:
             raise OGRException('Invalid input type for OGR Geometry construction: %s' % type(geom_input))

         # Now checking the Geometry pointer before finishing initialization
         # by setting the pointer for the object.
         if not g:
             raise OGRException('Cannot create OGR Geometry from input: %s' % str(geom_input))
         self._ptr = g

         # Assigning the SpatialReference object to the geometry, if valid.
         if bool(srs): self.srs = srs

         # Setting the class depending upon the OGR Geometry Type
         self.__class__ = GEO_CLASSES[self.geom_type.num]

     def __del__(self):
         "Deletes this Geometry."
         if self._ptr: destroy_geom(self._ptr)

     ### Geometry set-like operations ###
     # g = g1 | g2
     def __or__(self, other):
         "Returns the union of the two geometries."
         return self.union(other)

     # g = g1 & g2
     def __and__(self, other):
         "Returns the intersection of this Geometry and the other."
         return self.intersection(other)

     # g = g1 - g2
     def __sub__(self, other):
         "Return the difference this Geometry and the other."
         return self.difference(other)

     # g = g1 ^ g2
     def __xor__(self, other):
         "Return the symmetric difference of this Geometry and the other."
         return self.sym_difference(other)

     def __eq__(self, other):
         "Is this Geometry equal to the other?"
         return self.equals(other)

     def __ne__(self, other):
         "Tests for inequality."
         return not self.equals(other)

     def __str__(self):
         "WKT is used for the string representation."
         return self.wkt

     #### Geometry Properties ####
     @property
     def dimension(self):
         "Returns 0 for points, 1 for lines, and 2 for surfaces."
         return get_dims(self._ptr)

     @property
     def coord_dim(self):
         "Returns the coordinate dimension of the Geometry."
         return get_coord_dims(self._ptr)

     @property
     def geom_count(self):
         "The number of elements in this Geometry."
         return get_geom_count(self._ptr)

     @property
     def point_count(self):
         "Returns the number of Points in this Geometry."
         return get_point_count(self._ptr)

     @property
     def num_points(self):
         "Alias for `point_count` (same name method in GEOS API.)"
         return self.point_count

     @property
     def num_coords(self):
         "Alais for `point_count`."
         return self.point_count

     @property
     def geom_type(self):
         "Returns the Type for this Geometry."
         try:
             return OGRGeomType(get_geom_type(self._ptr))
         except OGRException:
             # VRT datasources return an invalid geometry type
             # number, but a valid name -- we'll try that instead.
             # See: http://trac.osgeo.org/gdal/ticket/2491
             return OGRGeomType(get_geom_name(self._ptr))

     @property
     def geom_name(self):
         "Returns the Name of this Geometry."
         return get_geom_name(self._ptr)

     @property
     def area(self):
         "Returns the area for a LinearRing, Polygon, or MultiPolygon; 0 otherwise."
         return get_area(self._ptr)

     @property
     def envelope(self):
         "Returns the envelope for this Geometry."
         # TODO: Fix Envelope() for Point geometries.
         return Envelope(get_envelope(self._ptr, byref(OGREnvelope())))

     @property
     def extent(self):
         "Returns the envelope as a 4-tuple, instead of as an Envelope object."
         return self.envelope.tuple

     #### SpatialReference-related Properties ####

     # The SRS property
     def get_srs(self):
         "Returns the Spatial Reference for this Geometry."
         try:
             srs_ptr = get_geom_srs(self._ptr)
             return SpatialReference(clone_srs(srs_ptr))
         except SRSException:
             return None

     def set_srs(self, srs):
         "Sets the SpatialReference for this geometry."
         if isinstance(srs, SpatialReference):
             srs_ptr = clone_srs(srs._ptr)
         elif isinstance(srs, (int, long, basestring)):
             sr = SpatialReference(srs)
             srs_ptr = clone_srs(sr._ptr)
         else:
             raise TypeError('Cannot assign spatial reference with object of type: %s' % type(srs))
         assign_srs(self._ptr, srs_ptr)

     srs = property(get_srs, set_srs)

     # The SRID property
     def get_srid(self):
         if self.srs: return self.srs.srid
         else: return None

     def set_srid(self, srid):
         if isinstance(srid, (int, long)):
             self.srs = srid
         else:
             raise TypeError('SRID must be set with an integer.')

     srid = property(get_srid, set_srid)

     #### Output Methods ####
     @property
     def geos(self):
         "Returns a GEOSGeometry object from this OGRGeometry."
         from django.contrib.gis.geos import GEOSGeometry
         return GEOSGeometry(self.wkb, self.srid)

     @property
     def gml(self):
         "Returns the GML representation of the Geometry."
         return to_gml(self._ptr)

     @property
     def hex(self):
         "Returns the hexadecimal representation of the WKB (a string)."
         return str(self.wkb).encode('hex').upper()
         #return b2a_hex(self.wkb).upper()

     @property
     def json(self):
         if GEOJSON:
             return to_json(self._ptr)
         else:
             raise NotImplementedError('GeoJSON output only supported on GDAL 1.5+.')
     geojson = json

     @property
     def wkb_size(self):
         "Returns the size of the WKB buffer."
         return get_wkbsize(self._ptr)

     @property
     def wkb(self):
         "Returns the WKB representation of the Geometry."
         if sys.byteorder == 'little':
             byteorder = 1 # wkbNDR (from ogr_core.h)
         else:
             byteorder = 0 # wkbXDR
         sz = self.wkb_size
         # Creating the unsigned character buffer, and passing it in by reference.
         buf = (c_ubyte * sz)()
         wkb = to_wkb(self._ptr, byteorder, byref(buf))
         # Returning a buffer of the string at the pointer.
         return buffer(string_at(buf, sz))

     @property
     def wkt(self):
         "Returns the WKT representation of the Geometry."
         return to_wkt(self._ptr, byref(c_char_p()))

     #### Geometry Methods ####
     def clone(self):
         "Clones this OGR Geometry."
         return OGRGeometry(clone_geom(self._ptr), self.srs)

     def close_rings(self):
         """
         If there are any rings within this geometry that have not been
         closed, this routine will do so by adding the starting point at the
         end.
         """
         # Closing the open rings.
         geom_close_rings(self._ptr)

     def transform(self, coord_trans, clone=False):
         """
         Transforms this geometry to a different spatial reference system.
         May take a CoordTransform object, a SpatialReference object, string
         WKT or PROJ.4, and/or an integer SRID.  By default nothing is returned
         and the geometry is transformed in-place.  However, if the `clone`
         keyword is set, then a transformed clone of this geometry will be
         returned.
         """
         if clone:
             klone = self.clone()
             klone.transform(coord_trans)
             return klone
         if isinstance(coord_trans, CoordTransform):
             geom_transform(self._ptr, coord_trans._ptr)
         elif isinstance(coord_trans, SpatialReference):
             geom_transform_to(self._ptr, coord_trans._ptr)
         elif isinstance(coord_trans, (int, long, basestring)):
             sr = SpatialReference(coord_trans)
             geom_transform_to(self._ptr, sr._ptr)
         else:
             raise TypeError('Transform only accepts CoordTransform, SpatialReference, string, and integer objects.')

     def transform_to(self, srs):
         "For backwards-compatibility."
         self.transform(srs)

     #### Topology Methods ####
     def _topology(self, func, other):
         """A generalized function for topology operations, takes a GDAL function and
         the other geometry to perform the operation on."""
         if not isinstance(other, OGRGeometry):
             raise TypeError('Must use another OGRGeometry object for topology operations!')

         # Returning the output of the given function with the other geometry's
         # pointer.
         return func(self._ptr, other._ptr)

     def intersects(self, other):
         "Returns True if this geometry intersects with the other."
         return self._topology(ogr_intersects, other)

     def equals(self, other):
         "Returns True if this geometry is equivalent to the other."
         return self._topology(ogr_equals, other)

     def disjoint(self, other):
         "Returns True if this geometry and the other are spatially disjoint."
         return self._topology(ogr_disjoint, other)

     def touches(self, other):
         "Returns True if this geometry touches the other."
         return self._topology(ogr_touches, other)

     def crosses(self, other):
         "Returns True if this geometry crosses the other."
         return self._topology(ogr_crosses, other)

     def within(self, other):
         "Returns True if this geometry is within the other."
         return self._topology(ogr_within, other)

     def contains(self, other):
         "Returns True if this geometry contains the other."
         return self._topology(ogr_contains, other)

     def overlaps(self, other):
         "Returns True if this geometry overlaps the other."
         return self._topology(ogr_overlaps, other)

     #### Geometry-generation Methods ####
     def _geomgen(self, gen_func, other=None):
         "A helper routine for the OGR routines that generate geometries."
         if isinstance(other, OGRGeometry):
             return OGRGeometry(gen_func(self._ptr, other._ptr), self.srs)
         else:
             return OGRGeometry(gen_func(self._ptr), self.srs)

     @property
     def boundary(self):
         "Returns the boundary of this geometry."
         return self._geomgen(get_boundary)

     @property
     def convex_hull(self):
         """
         Returns the smallest convex Polygon that contains all the points in
         this Geometry.
         """
         return self._geomgen(geom_convex_hull)

     def difference(self, other):
         """
         Returns a new geometry consisting of the region which is the difference
         of this geometry and the other.
         """
         return self._geomgen(geom_diff, other)

     def intersection(self, other):
         """
         Returns a new geometry consisting of the region of intersection of this
         geometry and the other.
         """
         return self._geomgen(geom_intersection, other)

     def sym_difference(self, other):
         """
         Returns a new geometry which is the symmetric difference of this
         geometry and the other.
         """
         return self._geomgen(geom_sym_diff, other)

     def union(self, other):
         """
         Returns a new geometry consisting of the region which is the union of
         this geometry and the other.
         """
         return self._geomgen(geom_union, other)

 # The subclasses for OGR Geometry.
 class Point(OGRGeometry):

     @property
     def x(self):
         "Returns the X coordinate for this Point."
         return getx(self._ptr, 0)

     @property
     def y(self):
         "Returns the Y coordinate for this Point."
         return gety(self._ptr, 0)

     @property
     def z(self):
         "Returns the Z coordinate for this Point."
         if self.coord_dim == 3:
             return getz(self._ptr, 0)

     @property
     def tuple(self):
         "Returns the tuple of this point."
         if self.coord_dim == 2:
             return (self.x, self.y)
         elif self.coord_dim == 3:
             return (self.x, self.y, self.z)
     coords = tuple

 class LineString(OGRGeometry):

     def __getitem__(self, index):
         "Returns the Point at the given index."
         if index >= 0 and index < self.point_count:
             x, y, z = c_double(), c_double(), c_double()
             get_point(self._ptr, index, byref(x), byref(y), byref(z))
             dim = self.coord_dim
             if dim == 1:
                 return (x.value,)
             elif dim == 2:
                 return (x.value, y.value)
             elif dim == 3:
                 return (x.value, y.value, z.value)
         else:
             raise OGRIndexError('index out of range: %s' % str(index))

     def __iter__(self):
         "Iterates over each point in the LineString."
         for i in xrange(self.point_count):
             yield self[i]

     def __len__(self):
         "The length returns the number of points in the LineString."
         return self.point_count

     @property
     def tuple(self):
         "Returns the tuple representation of this LineString."
         return tuple([self[i] for i in xrange(len(self))])
     coords = tuple

     def _listarr(self, func):
         """
         Internal routine that returns a sequence (list) corresponding with
         the given function.
         """
         return [func(self._ptr, i) for i in xrange(len(self))]

     @property
     def x(self):
         "Returns the X coordinates in a list."
         return self._listarr(getx)

     @property
     def y(self):
         "Returns the Y coordinates in a list."
         return self._listarr(gety)

     @property
     def z(self):
         "Returns the Z coordinates in a list."
         if self.coord_dim == 3:
             return self._listarr(getz)

 # LinearRings are used in Polygons.
 class LinearRing(LineString): pass

 class Polygon(OGRGeometry):

     def __len__(self):
         "The number of interior rings in this Polygon."
         return self.geom_count

     def __iter__(self):
         "Iterates through each ring in the Polygon."
         for i in xrange(self.geom_count):
             yield self[i]

     def __getitem__(self, index):
         "Gets the ring at the specified index."
         if index < 0 or index >= self.geom_count:
             raise OGRIndexError('index out of range: %s' % index)
         else:
             return OGRGeometry(clone_geom(get_geom_ref(self._ptr, index)), self.srs)

     # Polygon Properties
     @property
     def shell(self):
         "Returns the shell of this Polygon."
         return self[0] # First ring is the shell
     exterior_ring = shell

     @property
     def tuple(self):
         "Returns a tuple of LinearRing coordinate tuples."
         return tuple([self[i].tuple for i in xrange(self.geom_count)])
     coords = tuple

     @property
     def point_count(self):
         "The number of Points in this Polygon."
         # Summing up the number of points in each ring of the Polygon.
         return sum([self[i].point_count for i in xrange(self.geom_count)])

     @property
     def centroid(self):
         "Returns the centroid (a Point) of this Polygon."
         # The centroid is a Point, create a geometry for this.
         p = OGRGeometry(OGRGeomType('Point'))
         get_centroid(self._ptr, p._ptr)
         return p

 # Geometry Collection base class.
 class GeometryCollection(OGRGeometry):
     "The Geometry Collection class."

     def __getitem__(self, index):
         "Gets the Geometry at the specified index."
         if index < 0 or index >= self.geom_count:
             raise OGRIndexError('index out of range: %s' % index)
         else:
             return OGRGeometry(clone_geom(get_geom_ref(self._ptr, index)), self.srs)

     def __iter__(self):
         "Iterates over each Geometry."
         for i in xrange(self.geom_count):
             yield self[i]

     def __len__(self):
         "The number of geometries in this Geometry Collection."
         return self.geom_count

     def add(self, geom):
         "Add the geometry to this Geometry Collection."
         if isinstance(geom, OGRGeometry):
             if isinstance(geom, self.__class__):
                 for g in geom: add_geom(self._ptr, g._ptr)
             else:
                 add_geom(self._ptr, geom._ptr)
         elif isinstance(geom, basestring):
             tmp = OGRGeometry(geom)
             add_geom(self._ptr, tmp._ptr)
         else:
             raise OGRException('Must add an OGRGeometry.')

     @property
     def point_count(self):
         "The number of Points in this Geometry Collection."
         # Summing up the number of points in each geometry in this collection
         return sum([self[i].point_count for i in xrange(self.geom_count)])

     @property
     def tuple(self):
         "Returns a tuple representation of this Geometry Collection."
         return tuple([self[i].tuple for i in xrange(self.geom_count)])
     coords = tuple

 # Multiple Geometry types.
 class MultiPoint(GeometryCollection): pass
 class MultiLineString(GeometryCollection): pass
 class MultiPolygon(GeometryCollection): pass

 # Class mapping dictionary (using the OGRwkbGeometryType as the key)
 GEO_CLASSES = {1 : Point,
                2 : LineString,
                3 : Polygon,
                4 : MultiPoint,
                5 : MultiLineString,
                6 : MultiPolygon,
                7 : GeometryCollection,
                101: LinearRing,
                }
	"""
	The OGRGeometry is a wrapper for using the OGR Geometry class
	(see http://www.gdal.org/ogr/classOGRGeometry.html). OGRGeometry
	may be instantiated when reading geometries from OGR Data Sources
	(e.g. SHP files), or when given OGC WKT (a string).

	While the 'full' API is not present yet, the API is "pythonic" unlike
	the traditional and "next-generation" OGR Python bindings. One major
	advantage OGR Geometries have over their GEOS counterparts is support
	for spatial reference systems and their transformation.

	Example:
	>>> from django.contrib.gis.gdal import OGRGeometry, OGRGeomType, SpatialReference
	>>> wkt1, wkt2 = 'POINT(-90 30)', 'POLYGON((0 0, 5 0, 5 5, 0 5)'
	>>> pnt = OGRGeometry(wkt1)
	>>> print pnt
	POINT (-90 30)
	>>> mpnt = OGRGeometry(OGRGeomType('MultiPoint'), SpatialReference('WGS84'))
	>>> mpnt.add(wkt1)
	>>> mpnt.add(wkt1)
	>>> print mpnt
	MULTIPOINT (-90 30,-90 30)
	>>> print mpnt.srs.name
	WGS 84
	>>> print mpnt.srs.proj
	+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs
	>>> mpnt.transform_to(SpatialReference('NAD27'))
	>>> print mpnt.proj
	+proj=longlat +ellps=clrk66 +datum=NAD27 +no_defs
	>>> print mpnt
	MULTIPOINT (-89.999930378602485 29.999797886557641,-89.999930378602485 29.999797886557641)

	The OGRGeomType class is to make it easy to specify an OGR geometry type:
	>>> from django.contrib.gis.gdal import OGRGeomType
	>>> gt1 = OGRGeomType(3) # Using an integer for the type
	>>> gt2 = OGRGeomType('Polygon') # Using a string
	>>> gt3 = OGRGeomType('POLYGON') # It's case-insensitive
	>>> print gt1 == 3, gt1 == 'Polygon' # Equivalence works w/non-OGRGeomType objects
	True
	"""
	# Python library requisites.
	import re, sys
	from binascii import a2b_hex
	from ctypes import byref, string_at, c_char_p, c_double, c_ubyte, c_void_p
	from types import UnicodeType

	# Getting GDAL prerequisites
	from django.contrib.gis.gdal.envelope import Envelope, OGREnvelope
	from django.contrib.gis.gdal.error import OGRException, OGRIndexError, SRSException
	from django.contrib.gis.gdal.geomtype import OGRGeomType
	from django.contrib.gis.gdal.srs import SpatialReference, CoordTransform

	# Getting the ctypes prototype functions that interface w/the GDAL C library.
	from django.contrib.gis.gdal.prototypes.geom import *
	from django.contrib.gis.gdal.prototypes.srs import clone_srs

	# For more information, see the OGR C API source code:
	# http://www.gdal.org/ogr/ogr__api_8h.html
	#
	# The OGR_G_* routines are relevant here.

	# Regular expressions for recognizing HEXEWKB and WKT.
	hex_regex = re.compile(r'^[0-9A-F]+$', re.I)
	wkt_regex = re.compile(r'^(?P<type>POINT\|LINESTRING\|LINEARRING\|POLYGON\|MULTIPOINT\|MULTILINESTRING\|MULTIPOLYGON\|GEOMETRYCOLLECTION)[ACEGIMLONPSRUTY\d,\.\-\(\) ]+$', re.I)
	json_regex = re.compile(r'^\{[\s\w,\-\.\"\'\:\[\]]+\}$')

	#### OGRGeometry Class ####
	class OGRGeometry(object):
	"Generally encapsulates an OGR geometry."

	def __init__(self, geom_input, srs=None):
	"Initializes Geometry on either WKT or an OGR pointer as input."

	self._ptr = c_void_p(None) # Initially NULL
	str_instance = isinstance(geom_input, basestring)

	# If HEX, unpack input to to a binary buffer.
	if str_instance and hex_regex.match(geom_input):
	geom_input = buffer(a2b_hex(geom_input.upper()))
	str_instance = False

	# Constructing the geometry,
	if str_instance:
	# Checking if unicode
	if isinstance(geom_input, UnicodeType):
	# Encoding to ASCII, WKT or HEX doesn't need any more.
	geo_input = geo_input.encode('ascii')

	wkt_m = wkt_regex.match(geom_input)
	json_m = json_regex.match(geom_input)
	if wkt_m:
	if wkt_m.group('type').upper() == 'LINEARRING':
	# OGR_G_CreateFromWkt doesn't work with LINEARRING WKT.
	# See http://trac.osgeo.org/gdal/ticket/1992.
	g = create_geom(OGRGeomType(wkt_m.group('type')).num)
	import_wkt(g, byref(c_char_p(geom_input)))
	else:
	g = from_wkt(byref(c_char_p(geom_input)), None, byref(c_void_p()))
	elif json_m:
	if GEOJSON:
	g = from_json(geom_input)
	else:
	raise NotImplementedError('GeoJSON input only supported on GDAL 1.5+.')
	else:
	# Seeing if the input is a valid short-hand string
	# (e.g., 'Point', 'POLYGON').
	ogr_t = OGRGeomType(geom_input)
	g = create_geom(OGRGeomType(geom_input).num)
	elif isinstance(geom_input, buffer):
	# WKB was passed in
	g = from_wkb(str(geom_input), None, byref(c_void_p()), len(geom_input))
	elif isinstance(geom_input, OGRGeomType):
	# OGRGeomType was passed in, an empty geometry will be created.
	g = create_geom(geom_input.num)
	elif isinstance(geom_input, c_void_p):
	# OGR pointer (c_void_p) was the input.
	g = geom_input
	else:
	raise OGRException('Invalid input type for OGR Geometry construction: %s' % type(geom_input))

	# Now checking the Geometry pointer before finishing initialization
	# by setting the pointer for the object.
	if not g:
	raise OGRException('Cannot create OGR Geometry from input: %s' % str(geom_input))
	self._ptr = g

	# Assigning the SpatialReference object to the geometry, if valid.
	if bool(srs): self.srs = srs

	# Setting the class depending upon the OGR Geometry Type
	self.__class__ = GEO_CLASSES[self.geom_type.num]

	def __del__(self):
	"Deletes this Geometry."
	if self._ptr: destroy_geom(self._ptr)

	### Geometry set-like operations ###
	# g = g1 \| g2
	def __or__(self, other):
	"Returns the union of the two geometries."
	return self.union(other)

	# g = g1 & g2
	def __and__(self, other):
	"Returns the intersection of this Geometry and the other."
	return self.intersection(other)

	# g = g1 - g2
	def __sub__(self, other):
	"Return the difference this Geometry and the other."
	return self.difference(other)

	# g = g1 ^ g2
	def __xor__(self, other):
	"Return the symmetric difference of this Geometry and the other."
	return self.sym_difference(other)

	def __eq__(self, other):
	"Is this Geometry equal to the other?"
	return self.equals(other)

	def __ne__(self, other):
	"Tests for inequality."
	return not self.equals(other)

	def __str__(self):
	"WKT is used for the string representation."
	return self.wkt

	#### Geometry Properties ####
	@property
	def dimension(self):
	"Returns 0 for points, 1 for lines, and 2 for surfaces."
	return get_dims(self._ptr)

	@property
	def coord_dim(self):
	"Returns the coordinate dimension of the Geometry."
	return get_coord_dims(self._ptr)

	@property
	def geom_count(self):
	"The number of elements in this Geometry."
	return get_geom_count(self._ptr)

	@property
	def point_count(self):
	"Returns the number of Points in this Geometry."
	return get_point_count(self._ptr)

	@property
	def num_points(self):
	"Alias for `point_count` (same name method in GEOS API.)"
	return self.point_count

	@property
	def num_coords(self):
	"Alais for `point_count`."
	return self.point_count

	@property
	def geom_type(self):
	"Returns the Type for this Geometry."
	try:
	return OGRGeomType(get_geom_type(self._ptr))
	except OGRException:
	# VRT datasources return an invalid geometry type
	# number, but a valid name -- we'll try that instead.
	# See: http://trac.osgeo.org/gdal/ticket/2491
	return OGRGeomType(get_geom_name(self._ptr))

	@property
	def geom_name(self):
	"Returns the Name of this Geometry."
	return get_geom_name(self._ptr)

	@property
	def area(self):
	"Returns the area for a LinearRing, Polygon, or MultiPolygon; 0 otherwise."
	return get_area(self._ptr)

	@property
	def envelope(self):
	"Returns the envelope for this Geometry."
	# TODO: Fix Envelope() for Point geometries.
	return Envelope(get_envelope(self._ptr, byref(OGREnvelope())))

	@property
	def extent(self):
	"Returns the envelope as a 4-tuple, instead of as an Envelope object."
	return self.envelope.tuple

	#### SpatialReference-related Properties ####

	# The SRS property
	def get_srs(self):
	"Returns the Spatial Reference for this Geometry."
	try:
	srs_ptr = get_geom_srs(self._ptr)
	return SpatialReference(clone_srs(srs_ptr))
	except SRSException:
	return None

	def set_srs(self, srs):
	"Sets the SpatialReference for this geometry."
	if isinstance(srs, SpatialReference):
	srs_ptr = clone_srs(srs._ptr)
	elif isinstance(srs, (int, long, basestring)):
	sr = SpatialReference(srs)
	srs_ptr = clone_srs(sr._ptr)
	else:
	raise TypeError('Cannot assign spatial reference with object of type: %s' % type(srs))
	assign_srs(self._ptr, srs_ptr)

	srs = property(get_srs, set_srs)

	# The SRID property
	def get_srid(self):
	if self.srs: return self.srs.srid
	else: return None

	def set_srid(self, srid):
	if isinstance(srid, (int, long)):
	self.srs = srid
	else:
	raise TypeError('SRID must be set with an integer.')

	srid = property(get_srid, set_srid)

	#### Output Methods ####
	@property
	def geos(self):
	"Returns a GEOSGeometry object from this OGRGeometry."
	from django.contrib.gis.geos import GEOSGeometry
	return GEOSGeometry(self.wkb, self.srid)

	@property
	def gml(self):
	"Returns the GML representation of the Geometry."
	return to_gml(self._ptr)

	@property
	def hex(self):
	"Returns the hexadecimal representation of the WKB (a string)."
	return str(self.wkb).encode('hex').upper()
	#return b2a_hex(self.wkb).upper()

	@property
	def json(self):
	if GEOJSON:
	return to_json(self._ptr)
	else:
	raise NotImplementedError('GeoJSON output only supported on GDAL 1.5+.')
	geojson = json

	@property
	def wkb_size(self):
	"Returns the size of the WKB buffer."
	return get_wkbsize(self._ptr)

	@property
	def wkb(self):
	"Returns the WKB representation of the Geometry."
	if sys.byteorder == 'little':
	byteorder = 1 # wkbNDR (from ogr_core.h)
	else:
	byteorder = 0 # wkbXDR
	sz = self.wkb_size
	# Creating the unsigned character buffer, and passing it in by reference.
	buf = (c_ubyte * sz)()
	wkb = to_wkb(self._ptr, byteorder, byref(buf))
	# Returning a buffer of the string at the pointer.
	return buffer(string_at(buf, sz))

	@property
	def wkt(self):
	"Returns the WKT representation of the Geometry."
	return to_wkt(self._ptr, byref(c_char_p()))

	#### Geometry Methods ####
	def clone(self):
	"Clones this OGR Geometry."
	return OGRGeometry(clone_geom(self._ptr), self.srs)

	def close_rings(self):
	"""
	If there are any rings within this geometry that have not been
	closed, this routine will do so by adding the starting point at the
	end.
	"""
	# Closing the open rings.
	geom_close_rings(self._ptr)

	def transform(self, coord_trans, clone=False):
	"""
	Transforms this geometry to a different spatial reference system.
	May take a CoordTransform object, a SpatialReference object, string
	WKT or PROJ.4, and/or an integer SRID. By default nothing is returned
	and the geometry is transformed in-place. However, if the `clone`
	keyword is set, then a transformed clone of this geometry will be
	returned.
	"""
	if clone:
	klone = self.clone()
	klone.transform(coord_trans)
	return klone
	if isinstance(coord_trans, CoordTransform):
	geom_transform(self._ptr, coord_trans._ptr)
	elif isinstance(coord_trans, SpatialReference):
	geom_transform_to(self._ptr, coord_trans._ptr)
	elif isinstance(coord_trans, (int, long, basestring)):
	sr = SpatialReference(coord_trans)
	geom_transform_to(self._ptr, sr._ptr)
	else:
	raise TypeError('Transform only accepts CoordTransform, SpatialReference, string, and integer objects.')

	def transform_to(self, srs):
	"For backwards-compatibility."
	self.transform(srs)

	#### Topology Methods ####
	def _topology(self, func, other):
	"""A generalized function for topology operations, takes a GDAL function and
	the other geometry to perform the operation on."""
	if not isinstance(other, OGRGeometry):
	raise TypeError('Must use another OGRGeometry object for topology operations!')

	# Returning the output of the given function with the other geometry's
	# pointer.
	return func(self._ptr, other._ptr)

	def intersects(self, other):
	"Returns True if this geometry intersects with the other."
	return self._topology(ogr_intersects, other)

	def equals(self, other):
	"Returns True if this geometry is equivalent to the other."
	return self._topology(ogr_equals, other)

	def disjoint(self, other):
	"Returns True if this geometry and the other are spatially disjoint."
	return self._topology(ogr_disjoint, other)

	def touches(self, other):
	"Returns True if this geometry touches the other."
	return self._topology(ogr_touches, other)

	def crosses(self, other):
	"Returns True if this geometry crosses the other."
	return self._topology(ogr_crosses, other)

	def within(self, other):
	"Returns True if this geometry is within the other."
	return self._topology(ogr_within, other)

	def contains(self, other):
	"Returns True if this geometry contains the other."
	return self._topology(ogr_contains, other)

	def overlaps(self, other):
	"Returns True if this geometry overlaps the other."
	return self._topology(ogr_overlaps, other)

	#### Geometry-generation Methods ####
	def _geomgen(self, gen_func, other=None):
	"A helper routine for the OGR routines that generate geometries."
	if isinstance(other, OGRGeometry):
	return OGRGeometry(gen_func(self._ptr, other._ptr), self.srs)
	else:
	return OGRGeometry(gen_func(self._ptr), self.srs)

	@property
	def boundary(self):
	"Returns the boundary of this geometry."
	return self._geomgen(get_boundary)

	@property
	def convex_hull(self):
	"""
	Returns the smallest convex Polygon that contains all the points in
	this Geometry.
	"""
	return self._geomgen(geom_convex_hull)

	def difference(self, other):
	"""
	Returns a new geometry consisting of the region which is the difference
	of this geometry and the other.
	"""
	return self._geomgen(geom_diff, other)

	def intersection(self, other):
	"""
	Returns a new geometry consisting of the region of intersection of this
	geometry and the other.
	"""
	return self._geomgen(geom_intersection, other)

	def sym_difference(self, other):
	"""
	Returns a new geometry which is the symmetric difference of this
	geometry and the other.
	"""
	return self._geomgen(geom_sym_diff, other)

	def union(self, other):
	"""
	Returns a new geometry consisting of the region which is the union of
	this geometry and the other.
	"""
	return self._geomgen(geom_union, other)

	# The subclasses for OGR Geometry.
	class Point(OGRGeometry):

	@property
	def x(self):
	"Returns the X coordinate for this Point."
	return getx(self._ptr, 0)

	@property
	def y(self):
	"Returns the Y coordinate for this Point."
	return gety(self._ptr, 0)

	@property
	def z(self):
	"Returns the Z coordinate for this Point."
	if self.coord_dim == 3:
	return getz(self._ptr, 0)

	@property
	def tuple(self):
	"Returns the tuple of this point."
	if self.coord_dim == 2:
	return (self.x, self.y)
	elif self.coord_dim == 3:
	return (self.x, self.y, self.z)
	coords = tuple

	class LineString(OGRGeometry):

	def __getitem__(self, index):
	"Returns the Point at the given index."
	if index >= 0 and index < self.point_count:
	x, y, z = c_double(), c_double(), c_double()
	get_point(self._ptr, index, byref(x), byref(y), byref(z))
	dim = self.coord_dim
	if dim == 1:
	return (x.value,)
	elif dim == 2:
	return (x.value, y.value)
	elif dim == 3:
	return (x.value, y.value, z.value)
	else:
	raise OGRIndexError('index out of range: %s' % str(index))

	def __iter__(self):
	"Iterates over each point in the LineString."
	for i in xrange(self.point_count):
	yield self[i]

	def __len__(self):
	"The length returns the number of points in the LineString."
	return self.point_count

	@property
	def tuple(self):
	"Returns the tuple representation of this LineString."
	return tuple([self[i] for i in xrange(len(self))])
	coords = tuple

	def _listarr(self, func):
	"""
	Internal routine that returns a sequence (list) corresponding with
	the given function.
	"""
	return [func(self._ptr, i) for i in xrange(len(self))]

	@property
	def x(self):
	"Returns the X coordinates in a list."
	return self._listarr(getx)

	@property
	def y(self):
	"Returns the Y coordinates in a list."
	return self._listarr(gety)

	@property
	def z(self):
	"Returns the Z coordinates in a list."
	if self.coord_dim == 3:
	return self._listarr(getz)

	# LinearRings are used in Polygons.
	class LinearRing(LineString): pass

	class Polygon(OGRGeometry):

	def __len__(self):
	"The number of interior rings in this Polygon."
	return self.geom_count

	def __iter__(self):
	"Iterates through each ring in the Polygon."
	for i in xrange(self.geom_count):
	yield self[i]

	def __getitem__(self, index):
	"Gets the ring at the specified index."
	if index < 0 or index >= self.geom_count:
	raise OGRIndexError('index out of range: %s' % index)
	else:
	return OGRGeometry(clone_geom(get_geom_ref(self._ptr, index)), self.srs)

	# Polygon Properties
	@property
	def shell(self):
	"Returns the shell of this Polygon."
	return self[0] # First ring is the shell
	exterior_ring = shell

	@property
	def tuple(self):
	"Returns a tuple of LinearRing coordinate tuples."
	return tuple([self[i].tuple for i in xrange(self.geom_count)])
	coords = tuple

	@property
	def point_count(self):
	"The number of Points in this Polygon."
	# Summing up the number of points in each ring of the Polygon.
	return sum([self[i].point_count for i in xrange(self.geom_count)])

	@property
	def centroid(self):
	"Returns the centroid (a Point) of this Polygon."
	# The centroid is a Point, create a geometry for this.
	p = OGRGeometry(OGRGeomType('Point'))
	get_centroid(self._ptr, p._ptr)
	return p

	# Geometry Collection base class.
	class GeometryCollection(OGRGeometry):
	"The Geometry Collection class."

	def __getitem__(self, index):
	"Gets the Geometry at the specified index."
	if index < 0 or index >= self.geom_count:
	raise OGRIndexError('index out of range: %s' % index)
	else:
	return OGRGeometry(clone_geom(get_geom_ref(self._ptr, index)), self.srs)

	def __iter__(self):
	"Iterates over each Geometry."
	for i in xrange(self.geom_count):
	yield self[i]

	def __len__(self):
	"The number of geometries in this Geometry Collection."
	return self.geom_count

	def add(self, geom):
	"Add the geometry to this Geometry Collection."
	if isinstance(geom, OGRGeometry):
	if isinstance(geom, self.__class__):
	for g in geom: add_geom(self._ptr, g._ptr)
	else:
	add_geom(self._ptr, geom._ptr)
	elif isinstance(geom, basestring):
	tmp = OGRGeometry(geom)
	add_geom(self._ptr, tmp._ptr)
	else:
	raise OGRException('Must add an OGRGeometry.')

	@property
	def point_count(self):
	"The number of Points in this Geometry Collection."
	# Summing up the number of points in each geometry in this collection
	return sum([self[i].point_count for i in xrange(self.geom_count)])

	@property
	def tuple(self):
	"Returns a tuple representation of this Geometry Collection."
	return tuple([self[i].tuple for i in xrange(self.geom_count)])
	coords = tuple

	# Multiple Geometry types.
	class MultiPoint(GeometryCollection): pass
	class MultiLineString(GeometryCollection): pass
	class MultiPolygon(GeometryCollection): pass

	# Class mapping dictionary (using the OGRwkbGeometryType as the key)
	GEO_CLASSES = {1 : Point,
	2 : LineString,
	3 : Polygon,
	4 : MultiPoint,
	5 : MultiLineString,
	6 : MultiPolygon,
	7 : GeometryCollection,
	101: LinearRing,
	}