diff options
Diffstat (limited to 'webapp/django/contrib/gis/tests/test_gdal_geom.py')
| -rw-r--r-- | webapp/django/contrib/gis/tests/test_gdal_geom.py | 403 |
1 files changed, 403 insertions, 0 deletions
diff --git a/webapp/django/contrib/gis/tests/test_gdal_geom.py b/webapp/django/contrib/gis/tests/test_gdal_geom.py new file mode 100644 index 0000000000..b0dab0e9e8 --- /dev/null +++ b/webapp/django/contrib/gis/tests/test_gdal_geom.py @@ -0,0 +1,403 @@ +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 test00_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(TypeError, OGRGeomType.__init__, 23) + self.assertRaises(TypeError, OGRGeomType.__init__, 'fooD') + self.assertRaises(TypeError, OGRGeomType.__init__, 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(None, OGRGeomType('Unknown').django) + self.assertEqual(None, OGRGeomType('none').django) + + def test01a_wkt(self): + "Testing WKT output." + for g in wkt_out: + geom = OGRGeometry(g.wkt) + self.assertEqual(g.wkt, geom.wkt) + + 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) + 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." + 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 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 suite(): + s = unittest.TestSuite() + s.addTest(unittest.makeSuite(OGRGeomTest)) + return s + +def run(verbosity=2): + unittest.TextTestRunner(verbosity=verbosity).run(suite()) |