404 lines
16 KiB
Python
404 lines
16 KiB
Python
|
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())
|