--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/web/lib/django/contrib/gis/gdal/tests/test_geom.py Wed Jun 02 18:57:35 2010 +0200
@@ -0,0 +1,495 @@
+import unittest
+from django.contrib.gis.gdal import OGRGeometry, OGRGeomType, \
+ OGRException, OGRIndexError, SpatialReference, CoordTransform, \
+ gdal_version
+from django.contrib.gis.tests.geometries import *
+
+class OGRGeomTest(unittest.TestCase):
+ "This tests the OGR Geometry."
+
+ def test00a_geomtype(self):
+ "Testing OGRGeomType object."
+
+ # OGRGeomType should initialize on all these inputs.
+ try:
+ g = OGRGeomType(1)
+ g = OGRGeomType(7)
+ g = OGRGeomType('point')
+ g = OGRGeomType('GeometrycollectioN')
+ g = OGRGeomType('LINearrING')
+ g = OGRGeomType('Unknown')
+ except:
+ self.fail('Could not create an OGRGeomType object!')
+
+ # Should throw TypeError on this input
+ self.assertRaises(OGRException, OGRGeomType, 23)
+ self.assertRaises(OGRException, OGRGeomType, 'fooD')
+ self.assertRaises(OGRException, OGRGeomType, 9)
+
+ # Equivalence can take strings, ints, and other OGRGeomTypes
+ self.assertEqual(True, OGRGeomType(1) == OGRGeomType(1))
+ self.assertEqual(True, OGRGeomType(7) == 'GeometryCollection')
+ self.assertEqual(True, OGRGeomType('point') == 'POINT')
+ self.assertEqual(False, OGRGeomType('point') == 2)
+ self.assertEqual(True, OGRGeomType('unknown') == 0)
+ self.assertEqual(True, OGRGeomType(6) == 'MULtiPolyGON')
+ self.assertEqual(False, OGRGeomType(1) != OGRGeomType('point'))
+ self.assertEqual(True, OGRGeomType('POINT') != OGRGeomType(6))
+
+ # Testing the Django field name equivalent property.
+ self.assertEqual('PointField', OGRGeomType('Point').django)
+ self.assertEqual('GeometryField', OGRGeomType('Unknown').django)
+ self.assertEqual(None, OGRGeomType('none').django)
+
+ # 'Geometry' initialization implies an unknown geometry type.
+ gt = OGRGeomType('Geometry')
+ self.assertEqual(0, gt.num)
+ self.assertEqual('Unknown', gt.name)
+
+ def test00b_geomtype_25d(self):
+ "Testing OGRGeomType object with 25D types."
+ wkb25bit = OGRGeomType.wkb25bit
+ self.failUnless(OGRGeomType(wkb25bit + 1) == 'Point25D')
+ self.failUnless(OGRGeomType('MultiLineString25D') == (5 + wkb25bit))
+ self.assertEqual('GeometryCollectionField', OGRGeomType('GeometryCollection25D').django)
+
+ def test01a_wkt(self):
+ "Testing WKT output."
+ for g in wkt_out:
+ geom = OGRGeometry(g.wkt)
+ self.assertEqual(g.wkt, geom.wkt)
+
+ def test01a_ewkt(self):
+ "Testing EWKT input/output."
+ for ewkt_val in ('POINT (1 2 3)', 'LINEARRING (0 0,1 1,2 1,0 0)'):
+ # First with ewkt output when no SRID in EWKT
+ self.assertEqual(ewkt_val, OGRGeometry(ewkt_val).ewkt)
+ # No test consumption with an SRID specified.
+ ewkt_val = 'SRID=4326;%s' % ewkt_val
+ geom = OGRGeometry(ewkt_val)
+ self.assertEqual(ewkt_val, geom.ewkt)
+ self.assertEqual(4326, geom.srs.srid)
+
+ def test01b_gml(self):
+ "Testing GML output."
+ for g in wkt_out:
+ geom = OGRGeometry(g.wkt)
+ self.assertEqual(g.gml, geom.gml)
+
+ def test01c_hex(self):
+ "Testing HEX input/output."
+ for g in hex_wkt:
+ geom1 = OGRGeometry(g.wkt)
+ self.assertEqual(g.hex, geom1.hex)
+ # Constructing w/HEX
+ geom2 = OGRGeometry(g.hex)
+ self.assertEqual(geom1, geom2)
+
+ def test01d_wkb(self):
+ "Testing WKB input/output."
+ from binascii import b2a_hex
+ for g in hex_wkt:
+ geom1 = OGRGeometry(g.wkt)
+ wkb = geom1.wkb
+ self.assertEqual(b2a_hex(wkb).upper(), g.hex)
+ # Constructing w/WKB.
+ geom2 = OGRGeometry(wkb)
+ self.assertEqual(geom1, geom2)
+
+ def test01e_json(self):
+ "Testing GeoJSON input/output."
+ from django.contrib.gis.gdal.prototypes.geom import GEOJSON
+ if not GEOJSON: return
+ for g in json_geoms:
+ geom = OGRGeometry(g.wkt)
+ if not hasattr(g, 'not_equal'):
+ self.assertEqual(g.json, geom.json)
+ self.assertEqual(g.json, geom.geojson)
+ self.assertEqual(OGRGeometry(g.wkt), OGRGeometry(geom.json))
+
+ def test02_points(self):
+ "Testing Point objects."
+
+ prev = OGRGeometry('POINT(0 0)')
+ for p in points:
+ if not hasattr(p, 'z'): # No 3D
+ pnt = OGRGeometry(p.wkt)
+ self.assertEqual(1, pnt.geom_type)
+ self.assertEqual('POINT', pnt.geom_name)
+ self.assertEqual(p.x, pnt.x)
+ self.assertEqual(p.y, pnt.y)
+ self.assertEqual((p.x, p.y), pnt.tuple)
+
+ def test03_multipoints(self):
+ "Testing MultiPoint objects."
+
+ for mp in multipoints:
+ mgeom1 = OGRGeometry(mp.wkt) # First one from WKT
+ self.assertEqual(4, mgeom1.geom_type)
+ self.assertEqual('MULTIPOINT', mgeom1.geom_name)
+ mgeom2 = OGRGeometry('MULTIPOINT') # Creating empty multipoint
+ mgeom3 = OGRGeometry('MULTIPOINT')
+ for g in mgeom1:
+ mgeom2.add(g) # adding each point from the multipoints
+ mgeom3.add(g.wkt) # should take WKT as well
+ self.assertEqual(mgeom1, mgeom2) # they should equal
+ self.assertEqual(mgeom1, mgeom3)
+ self.assertEqual(mp.points, mgeom2.tuple)
+ self.assertEqual(mp.n_p, mgeom2.point_count)
+
+ def test04_linestring(self):
+ "Testing LineString objects."
+ prev = OGRGeometry('POINT(0 0)')
+ for ls in linestrings:
+ linestr = OGRGeometry(ls.wkt)
+ self.assertEqual(2, linestr.geom_type)
+ self.assertEqual('LINESTRING', linestr.geom_name)
+ self.assertEqual(ls.n_p, linestr.point_count)
+ self.assertEqual(ls.tup, linestr.tuple)
+ self.assertEqual(True, linestr == OGRGeometry(ls.wkt))
+ self.assertEqual(True, linestr != prev)
+ self.assertRaises(OGRIndexError, linestr.__getitem__, len(linestr))
+ prev = linestr
+
+ # Testing the x, y properties.
+ x = [tmpx for tmpx, tmpy in ls.tup]
+ y = [tmpy for tmpx, tmpy in ls.tup]
+ self.assertEqual(x, linestr.x)
+ self.assertEqual(y, linestr.y)
+
+ def test05_multilinestring(self):
+ "Testing MultiLineString objects."
+ prev = OGRGeometry('POINT(0 0)')
+ for mls in multilinestrings:
+ mlinestr = OGRGeometry(mls.wkt)
+ self.assertEqual(5, mlinestr.geom_type)
+ self.assertEqual('MULTILINESTRING', mlinestr.geom_name)
+ self.assertEqual(mls.n_p, mlinestr.point_count)
+ self.assertEqual(mls.tup, mlinestr.tuple)
+ self.assertEqual(True, mlinestr == OGRGeometry(mls.wkt))
+ self.assertEqual(True, mlinestr != prev)
+ prev = mlinestr
+ for ls in mlinestr:
+ self.assertEqual(2, ls.geom_type)
+ self.assertEqual('LINESTRING', ls.geom_name)
+ self.assertRaises(OGRIndexError, mlinestr.__getitem__, len(mlinestr))
+
+ def test06_linearring(self):
+ "Testing LinearRing objects."
+ prev = OGRGeometry('POINT(0 0)')
+ for rr in linearrings:
+ lr = OGRGeometry(rr.wkt)
+ #self.assertEqual(101, lr.geom_type.num)
+ self.assertEqual('LINEARRING', lr.geom_name)
+ self.assertEqual(rr.n_p, len(lr))
+ self.assertEqual(True, lr == OGRGeometry(rr.wkt))
+ self.assertEqual(True, lr != prev)
+ prev = lr
+
+ def test07a_polygons(self):
+ "Testing Polygon objects."
+
+ # Testing `from_bbox` class method
+ bbox = (-180,-90,180,90)
+ p = OGRGeometry.from_bbox( bbox )
+ self.assertEqual(bbox, p.extent)
+
+ prev = OGRGeometry('POINT(0 0)')
+ for p in polygons:
+ poly = OGRGeometry(p.wkt)
+ self.assertEqual(3, poly.geom_type)
+ self.assertEqual('POLYGON', poly.geom_name)
+ self.assertEqual(p.n_p, poly.point_count)
+ self.assertEqual(p.n_i + 1, len(poly))
+
+ # Testing area & centroid.
+ self.assertAlmostEqual(p.area, poly.area, 9)
+ x, y = poly.centroid.tuple
+ self.assertAlmostEqual(p.centroid[0], x, 9)
+ self.assertAlmostEqual(p.centroid[1], y, 9)
+
+ # Testing equivalence
+ self.assertEqual(True, poly == OGRGeometry(p.wkt))
+ self.assertEqual(True, poly != prev)
+
+ if p.ext_ring_cs:
+ ring = poly[0]
+ self.assertEqual(p.ext_ring_cs, ring.tuple)
+ self.assertEqual(p.ext_ring_cs, poly[0].tuple)
+ self.assertEqual(len(p.ext_ring_cs), ring.point_count)
+
+ for r in poly:
+ self.assertEqual('LINEARRING', r.geom_name)
+
+ def test07b_closepolygons(self):
+ "Testing closing Polygon objects."
+ # Both rings in this geometry are not closed.
+ poly = OGRGeometry('POLYGON((0 0, 5 0, 5 5, 0 5), (1 1, 2 1, 2 2, 2 1))')
+ self.assertEqual(8, poly.point_count)
+ print "\nBEGIN - expecting IllegalArgumentException; safe to ignore.\n"
+ try:
+ c = poly.centroid
+ except OGRException:
+ # Should raise an OGR exception, rings are not closed
+ pass
+ else:
+ self.fail('Should have raised an OGRException!')
+ print "\nEND - expecting IllegalArgumentException; safe to ignore.\n"
+
+ # Closing the rings -- doesn't work on GDAL versions 1.4.1 and below:
+ # http://trac.osgeo.org/gdal/ticket/1673
+ major, minor1, minor2 = gdal_version().split('.')
+ if major == '1':
+ iminor1 = int(minor1)
+ if iminor1 < 4 or (iminor1 == 4 and minor2.startswith('1')): return
+ poly.close_rings()
+ self.assertEqual(10, poly.point_count) # Two closing points should've been added
+ self.assertEqual(OGRGeometry('POINT(2.5 2.5)'), poly.centroid)
+
+ def test08_multipolygons(self):
+ "Testing MultiPolygon objects."
+ prev = OGRGeometry('POINT(0 0)')
+ for mp in multipolygons:
+ mpoly = OGRGeometry(mp.wkt)
+ self.assertEqual(6, mpoly.geom_type)
+ self.assertEqual('MULTIPOLYGON', mpoly.geom_name)
+ if mp.valid:
+ self.assertEqual(mp.n_p, mpoly.point_count)
+ self.assertEqual(mp.num_geom, len(mpoly))
+ self.assertRaises(OGRIndexError, mpoly.__getitem__, len(mpoly))
+ for p in mpoly:
+ self.assertEqual('POLYGON', p.geom_name)
+ self.assertEqual(3, p.geom_type)
+ self.assertEqual(mpoly.wkt, OGRGeometry(mp.wkt).wkt)
+
+ def test09a_srs(self):
+ "Testing OGR Geometries with Spatial Reference objects."
+ for mp in multipolygons:
+ # Creating a geometry w/spatial reference
+ sr = SpatialReference('WGS84')
+ mpoly = OGRGeometry(mp.wkt, sr)
+ self.assertEqual(sr.wkt, mpoly.srs.wkt)
+
+ # Ensuring that SRS is propagated to clones.
+ klone = mpoly.clone()
+ self.assertEqual(sr.wkt, klone.srs.wkt)
+
+ # Ensuring all children geometries (polygons and their rings) all
+ # return the assigned spatial reference as well.
+ for poly in mpoly:
+ self.assertEqual(sr.wkt, poly.srs.wkt)
+ for ring in poly:
+ self.assertEqual(sr.wkt, ring.srs.wkt)
+
+ # Ensuring SRS propagate in topological ops.
+ a, b = topology_geoms[0]
+ a, b = OGRGeometry(a.wkt, sr), OGRGeometry(b.wkt, sr)
+ diff = a.difference(b)
+ union = a.union(b)
+ self.assertEqual(sr.wkt, diff.srs.wkt)
+ self.assertEqual(sr.srid, union.srs.srid)
+
+ # Instantiating w/an integer SRID
+ mpoly = OGRGeometry(mp.wkt, 4326)
+ self.assertEqual(4326, mpoly.srid)
+ mpoly.srs = SpatialReference(4269)
+ self.assertEqual(4269, mpoly.srid)
+ self.assertEqual('NAD83', mpoly.srs.name)
+
+ # Incrementing through the multipolyogn after the spatial reference
+ # has been re-assigned.
+ for poly in mpoly:
+ self.assertEqual(mpoly.srs.wkt, poly.srs.wkt)
+ poly.srs = 32140
+ for ring in poly:
+ # Changing each ring in the polygon
+ self.assertEqual(32140, ring.srs.srid)
+ self.assertEqual('NAD83 / Texas South Central', ring.srs.name)
+ ring.srs = str(SpatialReference(4326)) # back to WGS84
+ self.assertEqual(4326, ring.srs.srid)
+
+ # Using the `srid` property.
+ ring.srid = 4322
+ self.assertEqual('WGS 72', ring.srs.name)
+ self.assertEqual(4322, ring.srid)
+
+ def test09b_srs_transform(self):
+ "Testing transform()."
+ orig = OGRGeometry('POINT (-104.609 38.255)', 4326)
+ trans = OGRGeometry('POINT (992385.4472045 481455.4944650)', 2774)
+
+ # Using an srid, a SpatialReference object, and a CoordTransform object
+ # or transformations.
+ t1, t2, t3 = orig.clone(), orig.clone(), orig.clone()
+ t1.transform(trans.srid)
+ t2.transform(SpatialReference('EPSG:2774'))
+ ct = CoordTransform(SpatialReference('WGS84'), SpatialReference(2774))
+ t3.transform(ct)
+
+ # Testing use of the `clone` keyword.
+ k1 = orig.clone()
+ k2 = k1.transform(trans.srid, clone=True)
+ self.assertEqual(k1, orig)
+ self.assertNotEqual(k1, k2)
+
+ prec = 3
+ for p in (t1, t2, t3, k2):
+ self.assertAlmostEqual(trans.x, p.x, prec)
+ self.assertAlmostEqual(trans.y, p.y, prec)
+
+ def test09c_transform_dim(self):
+ "Testing coordinate dimension is the same on transformed geometries."
+ ls_orig = OGRGeometry('LINESTRING(-104.609 38.255)', 4326)
+ ls_trans = OGRGeometry('LINESTRING(992385.4472045 481455.4944650)', 2774)
+
+ prec = 3
+ ls_orig.transform(ls_trans.srs)
+ # Making sure the coordinate dimension is still 2D.
+ self.assertEqual(2, ls_orig.coord_dim)
+ self.assertAlmostEqual(ls_trans.x[0], ls_orig.x[0], prec)
+ self.assertAlmostEqual(ls_trans.y[0], ls_orig.y[0], prec)
+
+ def test10_difference(self):
+ "Testing difference()."
+ for i in xrange(len(topology_geoms)):
+ g_tup = topology_geoms[i]
+ a = OGRGeometry(g_tup[0].wkt)
+ b = OGRGeometry(g_tup[1].wkt)
+ d1 = OGRGeometry(diff_geoms[i].wkt)
+ d2 = a.difference(b)
+ self.assertEqual(d1, d2)
+ self.assertEqual(d1, a - b) # __sub__ is difference operator
+ a -= b # testing __isub__
+ self.assertEqual(d1, a)
+
+ def test11_intersection(self):
+ "Testing intersects() and intersection()."
+ for i in xrange(len(topology_geoms)):
+ g_tup = topology_geoms[i]
+ a = OGRGeometry(g_tup[0].wkt)
+ b = OGRGeometry(g_tup[1].wkt)
+ i1 = OGRGeometry(intersect_geoms[i].wkt)
+ self.assertEqual(True, a.intersects(b))
+ i2 = a.intersection(b)
+ self.assertEqual(i1, i2)
+ self.assertEqual(i1, a & b) # __and__ is intersection operator
+ a &= b # testing __iand__
+ self.assertEqual(i1, a)
+
+ def test12_symdifference(self):
+ "Testing sym_difference()."
+ for i in xrange(len(topology_geoms)):
+ g_tup = topology_geoms[i]
+ a = OGRGeometry(g_tup[0].wkt)
+ b = OGRGeometry(g_tup[1].wkt)
+ d1 = OGRGeometry(sdiff_geoms[i].wkt)
+ d2 = a.sym_difference(b)
+ self.assertEqual(d1, d2)
+ self.assertEqual(d1, a ^ b) # __xor__ is symmetric difference operator
+ a ^= b # testing __ixor__
+ self.assertEqual(d1, a)
+
+ def test13_union(self):
+ "Testing union()."
+ for i in xrange(len(topology_geoms)):
+ g_tup = topology_geoms[i]
+ a = OGRGeometry(g_tup[0].wkt)
+ b = OGRGeometry(g_tup[1].wkt)
+ u1 = OGRGeometry(union_geoms[i].wkt)
+ u2 = a.union(b)
+ self.assertEqual(u1, u2)
+ self.assertEqual(u1, a | b) # __or__ is union operator
+ a |= b # testing __ior__
+ self.assertEqual(u1, a)
+
+ def test14_add(self):
+ "Testing GeometryCollection.add()."
+ # Can't insert a Point into a MultiPolygon.
+ mp = OGRGeometry('MultiPolygon')
+ pnt = OGRGeometry('POINT(5 23)')
+ self.assertRaises(OGRException, mp.add, pnt)
+
+ # GeometryCollection.add may take an OGRGeometry (if another collection
+ # of the same type all child geoms will be added individually) or WKT.
+ for mp in multipolygons:
+ mpoly = OGRGeometry(mp.wkt)
+ mp1 = OGRGeometry('MultiPolygon')
+ mp2 = OGRGeometry('MultiPolygon')
+ mp3 = OGRGeometry('MultiPolygon')
+
+ for poly in mpoly:
+ mp1.add(poly) # Adding a geometry at a time
+ mp2.add(poly.wkt) # Adding WKT
+ mp3.add(mpoly) # Adding a MultiPolygon's entire contents at once.
+ for tmp in (mp1, mp2, mp3): self.assertEqual(mpoly, tmp)
+
+ def test15_extent(self):
+ "Testing `extent` property."
+ # The xmin, ymin, xmax, ymax of the MultiPoint should be returned.
+ mp = OGRGeometry('MULTIPOINT(5 23, 0 0, 10 50)')
+ self.assertEqual((0.0, 0.0, 10.0, 50.0), mp.extent)
+ # Testing on the 'real world' Polygon.
+ poly = OGRGeometry(polygons[3].wkt)
+ ring = poly.shell
+ x, y = ring.x, ring.y
+ xmin, ymin = min(x), min(y)
+ xmax, ymax = max(x), max(y)
+ self.assertEqual((xmin, ymin, xmax, ymax), poly.extent)
+
+ def test16_25D(self):
+ "Testing 2.5D geometries."
+ pnt_25d = OGRGeometry('POINT(1 2 3)')
+ self.assertEqual('Point25D', pnt_25d.geom_type.name)
+ self.assertEqual(3.0, pnt_25d.z)
+ self.assertEqual(3, pnt_25d.coord_dim)
+ ls_25d = OGRGeometry('LINESTRING(1 1 1,2 2 2,3 3 3)')
+ self.assertEqual('LineString25D', ls_25d.geom_type.name)
+ self.assertEqual([1.0, 2.0, 3.0], ls_25d.z)
+ self.assertEqual(3, ls_25d.coord_dim)
+
+ def test17_pickle(self):
+ "Testing pickle support."
+ import cPickle
+ g1 = OGRGeometry('LINESTRING(1 1 1,2 2 2,3 3 3)', 'WGS84')
+ g2 = cPickle.loads(cPickle.dumps(g1))
+ self.assertEqual(g1, g2)
+ self.assertEqual(4326, g2.srs.srid)
+ self.assertEqual(g1.srs.wkt, g2.srs.wkt)
+
+ def test18_ogrgeometry_transform_workaround(self):
+ "Testing coordinate dimensions on geometries after transformation."
+ # A bug in GDAL versions prior to 1.7 changes the coordinate
+ # dimension of a geometry after it has been transformed.
+ # This test ensures that the bug workarounds employed within
+ # `OGRGeometry.transform` indeed work.
+ wkt_2d = "MULTILINESTRING ((0 0,1 1,2 2))"
+ wkt_3d = "MULTILINESTRING ((0 0 0,1 1 1,2 2 2))"
+ srid = 4326
+
+ # For both the 2D and 3D MultiLineString, ensure _both_ the dimension
+ # of the collection and the component LineString have the expected
+ # coordinate dimension after transform.
+ geom = OGRGeometry(wkt_2d, srid)
+ geom.transform(srid)
+ self.assertEqual(2, geom.coord_dim)
+ self.assertEqual(2, geom[0].coord_dim)
+ self.assertEqual(wkt_2d, geom.wkt)
+
+ geom = OGRGeometry(wkt_3d, srid)
+ geom.transform(srid)
+ self.assertEqual(3, geom.coord_dim)
+ self.assertEqual(3, geom[0].coord_dim)
+ self.assertEqual(wkt_3d, geom.wkt)
+
+ def test19_equivalence_regression(self):
+ "Testing equivalence methods with non-OGRGeometry instances."
+ self.assertNotEqual(None, OGRGeometry('POINT(0 0)'))
+ self.assertEqual(False, OGRGeometry('LINESTRING(0 0, 1 1)') == 3)
+
+def suite():
+ s = unittest.TestSuite()
+ s.addTest(unittest.makeSuite(OGRGeomTest))
+ return s
+
+def run(verbosity=2):
+ unittest.TextTestRunner(verbosity=verbosity).run(suite())