mirror of
https://github.com/django/django.git
synced 2025-10-31 09:41:08 +00:00
[1.8.x] Moved contrib.gis tests out of contrib.
Backport of ad0be620ae from master
This commit is contained in:
Tim Graham
Binary file not shown.
@@ -1,49 +0,0 @@
|
||||
import unittest
|
||||
|
||||
from django.contrib.gis.gdal import HAS_GDAL
|
||||
|
||||
if HAS_GDAL:
|
||||
from django.contrib.gis.gdal import Driver, GDALException
|
||||
|
||||
|
||||
valid_drivers = (
|
||||
# vector
|
||||
'ESRI Shapefile', 'MapInfo File', 'TIGER', 'S57', 'DGN', 'Memory', 'CSV',
|
||||
'GML', 'KML',
|
||||
# raster
|
||||
'GTiff', 'JPEG', 'MEM', 'PNG',
|
||||
)
|
||||
|
||||
invalid_drivers = ('Foo baz', 'clucka', 'ESRI Shp', 'ESRI rast')
|
||||
|
||||
aliases = {
|
||||
'eSrI': 'ESRI Shapefile',
|
||||
'TigER/linE': 'TIGER',
|
||||
'SHAPE': 'ESRI Shapefile',
|
||||
'sHp': 'ESRI Shapefile',
|
||||
'tiFf': 'GTiff',
|
||||
'tIf': 'GTiff',
|
||||
'jPEg': 'JPEG',
|
||||
'jpG': 'JPEG',
|
||||
}
|
||||
|
||||
|
||||
@unittest.skipUnless(HAS_GDAL, "GDAL is required")
|
||||
class DriverTest(unittest.TestCase):
|
||||
|
||||
def test01_valid_driver(self):
|
||||
"Testing valid GDAL/OGR Data Source Drivers."
|
||||
for d in valid_drivers:
|
||||
dr = Driver(d)
|
||||
self.assertEqual(d, str(dr))
|
||||
|
||||
def test02_invalid_driver(self):
|
||||
"Testing invalid GDAL/OGR Data Source Drivers."
|
||||
for i in invalid_drivers:
|
||||
self.assertRaises(GDALException, Driver, i)
|
||||
|
||||
def test03_aliases(self):
|
||||
"Testing driver aliases."
|
||||
for alias, full_name in aliases.items():
|
||||
dr = Driver(alias)
|
||||
self.assertEqual(full_name, str(dr))
|
||||
@@ -1,273 +0,0 @@
|
||||
import os
|
||||
import unittest
|
||||
from unittest import skipUnless
|
||||
|
||||
from django.contrib.gis.gdal import HAS_GDAL
|
||||
from django.contrib.gis.geometry.test_data import (
|
||||
TEST_DATA, TestDS, get_ds_file,
|
||||
)
|
||||
|
||||
if HAS_GDAL:
|
||||
from django.contrib.gis.gdal import DataSource, Envelope, OGRGeometry, GDALException, OGRIndexError, GDAL_VERSION
|
||||
from django.contrib.gis.gdal.field import OFTReal, OFTInteger, OFTString
|
||||
|
||||
# List of acceptable data sources.
|
||||
ds_list = (
|
||||
TestDS('test_point', nfeat=5, nfld=3, geom='POINT', gtype=1, driver='ESRI Shapefile',
|
||||
fields={'dbl': OFTReal, 'int': OFTInteger, 'str': OFTString},
|
||||
extent=(-1.35011, 0.166623, -0.524093, 0.824508), # Got extent from QGIS
|
||||
srs_wkt=(
|
||||
'GEOGCS["GCS_WGS_1984",DATUM["WGS_1984",SPHEROID["WGS_1984",'
|
||||
'6378137,298.257223563]],PRIMEM["Greenwich",0],UNIT["Degree",'
|
||||
'0.017453292519943295]]'
|
||||
),
|
||||
field_values={
|
||||
'dbl': [float(i) for i in range(1, 6)],
|
||||
'int': list(range(1, 6)),
|
||||
'str': [str(i) for i in range(1, 6)],
|
||||
},
|
||||
fids=range(5)
|
||||
),
|
||||
TestDS('test_vrt', ext='vrt', nfeat=3, nfld=3, geom='POINT', gtype='Point25D', driver='VRT',
|
||||
fields={
|
||||
'POINT_X': OFTString,
|
||||
'POINT_Y': OFTString,
|
||||
'NUM': OFTString,
|
||||
}, # VRT uses CSV, which all types are OFTString.
|
||||
extent=(1.0, 2.0, 100.0, 523.5), # Min/Max from CSV
|
||||
field_values={
|
||||
'POINT_X': ['1.0', '5.0', '100.0'],
|
||||
'POINT_Y': ['2.0', '23.0', '523.5'],
|
||||
'NUM': ['5', '17', '23'],
|
||||
},
|
||||
fids=range(1, 4)
|
||||
),
|
||||
TestDS('test_poly', nfeat=3, nfld=3, geom='POLYGON', gtype=3,
|
||||
driver='ESRI Shapefile',
|
||||
fields={'float': OFTReal, 'int': OFTInteger, 'str': OFTString},
|
||||
extent=(-1.01513, -0.558245, 0.161876, 0.839637), # Got extent from QGIS
|
||||
srs_wkt=(
|
||||
'GEOGCS["GCS_WGS_1984",DATUM["WGS_1984",SPHEROID["WGS_1984",'
|
||||
'6378137,298.257223563]],PRIMEM["Greenwich",0],UNIT["Degree",'
|
||||
'0.017453292519943295]]'
|
||||
),
|
||||
)
|
||||
)
|
||||
|
||||
bad_ds = (TestDS('foo'),)
|
||||
|
||||
|
||||
@skipUnless(HAS_GDAL, "GDAL is required")
|
||||
class DataSourceTest(unittest.TestCase):
|
||||
|
||||
def test01_valid_shp(self):
|
||||
"Testing valid SHP Data Source files."
|
||||
|
||||
for source in ds_list:
|
||||
# Loading up the data source
|
||||
ds = DataSource(source.ds)
|
||||
|
||||
# Making sure the layer count is what's expected (only 1 layer in a SHP file)
|
||||
self.assertEqual(1, len(ds))
|
||||
|
||||
# Making sure GetName works
|
||||
self.assertEqual(source.ds, ds.name)
|
||||
|
||||
# Making sure the driver name matches up
|
||||
self.assertEqual(source.driver, str(ds.driver))
|
||||
|
||||
# Making sure indexing works
|
||||
try:
|
||||
ds[len(ds)]
|
||||
except OGRIndexError:
|
||||
pass
|
||||
else:
|
||||
self.fail('Expected an IndexError!')
|
||||
|
||||
def test02_invalid_shp(self):
|
||||
"Testing invalid SHP files for the Data Source."
|
||||
for source in bad_ds:
|
||||
self.assertRaises(GDALException, DataSource, source.ds)
|
||||
|
||||
def test03a_layers(self):
|
||||
"Testing Data Source Layers."
|
||||
for source in ds_list:
|
||||
ds = DataSource(source.ds)
|
||||
|
||||
# Incrementing through each layer, this tests DataSource.__iter__
|
||||
for layer in ds:
|
||||
# Making sure we get the number of features we expect
|
||||
self.assertEqual(len(layer), source.nfeat)
|
||||
|
||||
# Making sure we get the number of fields we expect
|
||||
self.assertEqual(source.nfld, layer.num_fields)
|
||||
self.assertEqual(source.nfld, len(layer.fields))
|
||||
|
||||
# Testing the layer's extent (an Envelope), and its properties
|
||||
if source.driver == 'VRT' and (GDAL_VERSION >= (1, 7, 0) and GDAL_VERSION < (1, 7, 3)):
|
||||
# There's a known GDAL regression with retrieving the extent
|
||||
# of a VRT layer in versions 1.7.0-1.7.2:
|
||||
# http://trac.osgeo.org/gdal/ticket/3783
|
||||
pass
|
||||
else:
|
||||
self.assertEqual(True, isinstance(layer.extent, Envelope))
|
||||
self.assertAlmostEqual(source.extent[0], layer.extent.min_x, 5)
|
||||
self.assertAlmostEqual(source.extent[1], layer.extent.min_y, 5)
|
||||
self.assertAlmostEqual(source.extent[2], layer.extent.max_x, 5)
|
||||
self.assertAlmostEqual(source.extent[3], layer.extent.max_y, 5)
|
||||
|
||||
# Now checking the field names.
|
||||
flds = layer.fields
|
||||
for f in flds:
|
||||
self.assertEqual(True, f in source.fields)
|
||||
|
||||
# Negative FIDs are not allowed.
|
||||
self.assertRaises(OGRIndexError, layer.__getitem__, -1)
|
||||
self.assertRaises(OGRIndexError, layer.__getitem__, 50000)
|
||||
|
||||
if hasattr(source, 'field_values'):
|
||||
fld_names = source.field_values.keys()
|
||||
|
||||
# Testing `Layer.get_fields` (which uses Layer.__iter__)
|
||||
for fld_name in fld_names:
|
||||
self.assertEqual(source.field_values[fld_name], layer.get_fields(fld_name))
|
||||
|
||||
# Testing `Layer.__getitem__`.
|
||||
for i, fid in enumerate(source.fids):
|
||||
feat = layer[fid]
|
||||
self.assertEqual(fid, feat.fid)
|
||||
# Maybe this should be in the test below, but we might as well test
|
||||
# the feature values here while in this loop.
|
||||
for fld_name in fld_names:
|
||||
self.assertEqual(source.field_values[fld_name][i], feat.get(fld_name))
|
||||
|
||||
def test03b_layer_slice(self):
|
||||
"Test indexing and slicing on Layers."
|
||||
# Using the first data-source because the same slice
|
||||
# can be used for both the layer and the control values.
|
||||
source = ds_list[0]
|
||||
ds = DataSource(source.ds)
|
||||
|
||||
sl = slice(1, 3)
|
||||
feats = ds[0][sl]
|
||||
|
||||
for fld_name in ds[0].fields:
|
||||
test_vals = [feat.get(fld_name) for feat in feats]
|
||||
control_vals = source.field_values[fld_name][sl]
|
||||
self.assertEqual(control_vals, test_vals)
|
||||
|
||||
def test03c_layer_references(self):
|
||||
"""
|
||||
Ensure OGR objects keep references to the objects they belong to.
|
||||
"""
|
||||
source = ds_list[0]
|
||||
|
||||
# See ticket #9448.
|
||||
def get_layer():
|
||||
# This DataSource object is not accessible outside this
|
||||
# scope. However, a reference should still be kept alive
|
||||
# on the `Layer` returned.
|
||||
ds = DataSource(source.ds)
|
||||
return ds[0]
|
||||
|
||||
# Making sure we can call OGR routines on the Layer returned.
|
||||
lyr = get_layer()
|
||||
self.assertEqual(source.nfeat, len(lyr))
|
||||
self.assertEqual(source.gtype, lyr.geom_type.num)
|
||||
|
||||
# Same issue for Feature/Field objects, see #18640
|
||||
self.assertEqual(str(lyr[0]['str']), "1")
|
||||
|
||||
def test04_features(self):
|
||||
"Testing Data Source Features."
|
||||
for source in ds_list:
|
||||
ds = DataSource(source.ds)
|
||||
|
||||
# Incrementing through each layer
|
||||
for layer in ds:
|
||||
# Incrementing through each feature in the layer
|
||||
for feat in layer:
|
||||
# Making sure the number of fields, and the geometry type
|
||||
# are what's expected.
|
||||
self.assertEqual(source.nfld, len(list(feat)))
|
||||
self.assertEqual(source.gtype, feat.geom_type)
|
||||
|
||||
# Making sure the fields match to an appropriate OFT type.
|
||||
for k, v in source.fields.items():
|
||||
# Making sure we get the proper OGR Field instance, using
|
||||
# a string value index for the feature.
|
||||
self.assertEqual(True, isinstance(feat[k], v))
|
||||
|
||||
# Testing Feature.__iter__
|
||||
for fld in feat:
|
||||
self.assertEqual(True, fld.name in source.fields.keys())
|
||||
|
||||
def test05_geometries(self):
|
||||
"Testing Geometries from Data Source Features."
|
||||
for source in ds_list:
|
||||
ds = DataSource(source.ds)
|
||||
|
||||
# Incrementing through each layer and feature.
|
||||
for layer in ds:
|
||||
for feat in layer:
|
||||
g = feat.geom
|
||||
|
||||
# Making sure we get the right Geometry name & type
|
||||
self.assertEqual(source.geom, g.geom_name)
|
||||
self.assertEqual(source.gtype, g.geom_type)
|
||||
|
||||
# Making sure the SpatialReference is as expected.
|
||||
if hasattr(source, 'srs_wkt'):
|
||||
self.assertEqual(
|
||||
source.srs_wkt,
|
||||
# Depending on lib versions, WGS_84 might be WGS_1984
|
||||
g.srs.wkt.replace('SPHEROID["WGS_84"', 'SPHEROID["WGS_1984"')
|
||||
)
|
||||
|
||||
def test06_spatial_filter(self):
|
||||
"Testing the Layer.spatial_filter property."
|
||||
ds = DataSource(get_ds_file('cities', 'shp'))
|
||||
lyr = ds[0]
|
||||
|
||||
# When not set, it should be None.
|
||||
self.assertEqual(None, lyr.spatial_filter)
|
||||
|
||||
# Must be set a/an OGRGeometry or 4-tuple.
|
||||
self.assertRaises(TypeError, lyr._set_spatial_filter, 'foo')
|
||||
|
||||
# Setting the spatial filter with a tuple/list with the extent of
|
||||
# a buffer centering around Pueblo.
|
||||
self.assertRaises(ValueError, lyr._set_spatial_filter, list(range(5)))
|
||||
filter_extent = (-105.609252, 37.255001, -103.609252, 39.255001)
|
||||
lyr.spatial_filter = (-105.609252, 37.255001, -103.609252, 39.255001)
|
||||
self.assertEqual(OGRGeometry.from_bbox(filter_extent), lyr.spatial_filter)
|
||||
feats = [feat for feat in lyr]
|
||||
self.assertEqual(1, len(feats))
|
||||
self.assertEqual('Pueblo', feats[0].get('Name'))
|
||||
|
||||
# Setting the spatial filter with an OGRGeometry for buffer centering
|
||||
# around Houston.
|
||||
filter_geom = OGRGeometry(
|
||||
'POLYGON((-96.363151 28.763374,-94.363151 28.763374,'
|
||||
'-94.363151 30.763374,-96.363151 30.763374,-96.363151 28.763374))'
|
||||
)
|
||||
lyr.spatial_filter = filter_geom
|
||||
self.assertEqual(filter_geom, lyr.spatial_filter)
|
||||
feats = [feat for feat in lyr]
|
||||
self.assertEqual(1, len(feats))
|
||||
self.assertEqual('Houston', feats[0].get('Name'))
|
||||
|
||||
# Clearing the spatial filter by setting it to None. Now
|
||||
# should indicate that there are 3 features in the Layer.
|
||||
lyr.spatial_filter = None
|
||||
self.assertEqual(3, len(lyr))
|
||||
|
||||
def test07_integer_overflow(self):
|
||||
"Testing that OFTReal fields, treated as OFTInteger, do not overflow."
|
||||
# Using *.dbf from Census 2010 TIGER Shapefile for Texas,
|
||||
# which has land area ('ALAND10') stored in a Real field
|
||||
# with no precision.
|
||||
ds = DataSource(os.path.join(TEST_DATA, 'texas.dbf'))
|
||||
feat = ds[0][0]
|
||||
# Reference value obtained using `ogrinfo`.
|
||||
self.assertEqual(676586997978, feat.get('ALAND10'))
|
||||
@@ -1,94 +0,0 @@
|
||||
import unittest
|
||||
from unittest import skipUnless
|
||||
|
||||
from django.contrib.gis.gdal import HAS_GDAL
|
||||
|
||||
if HAS_GDAL:
|
||||
from django.contrib.gis.gdal import Envelope, GDALException
|
||||
|
||||
|
||||
class TestPoint(object):
|
||||
def __init__(self, x, y):
|
||||
self.x = x
|
||||
self.y = y
|
||||
|
||||
|
||||
@skipUnless(HAS_GDAL, "GDAL is required")
|
||||
class EnvelopeTest(unittest.TestCase):
|
||||
|
||||
def setUp(self):
|
||||
self.e = Envelope(0, 0, 5, 5)
|
||||
|
||||
def test01_init(self):
|
||||
"Testing Envelope initialization."
|
||||
e1 = Envelope((0, 0, 5, 5))
|
||||
Envelope(0, 0, 5, 5)
|
||||
Envelope(0, '0', '5', 5) # Thanks to ww for this
|
||||
Envelope(e1._envelope)
|
||||
self.assertRaises(GDALException, Envelope, (5, 5, 0, 0))
|
||||
self.assertRaises(GDALException, Envelope, 5, 5, 0, 0)
|
||||
self.assertRaises(GDALException, Envelope, (0, 0, 5, 5, 3))
|
||||
self.assertRaises(GDALException, Envelope, ())
|
||||
self.assertRaises(ValueError, Envelope, 0, 'a', 5, 5)
|
||||
self.assertRaises(TypeError, Envelope, 'foo')
|
||||
self.assertRaises(GDALException, Envelope, (1, 1, 0, 0))
|
||||
try:
|
||||
Envelope(0, 0, 0, 0)
|
||||
except GDALException:
|
||||
self.fail("shouldn't raise an exception for min_x == max_x or min_y == max_y")
|
||||
|
||||
def test02_properties(self):
|
||||
"Testing Envelope properties."
|
||||
e = Envelope(0, 0, 2, 3)
|
||||
self.assertEqual(0, e.min_x)
|
||||
self.assertEqual(0, e.min_y)
|
||||
self.assertEqual(2, e.max_x)
|
||||
self.assertEqual(3, e.max_y)
|
||||
self.assertEqual((0, 0), e.ll)
|
||||
self.assertEqual((2, 3), e.ur)
|
||||
self.assertEqual((0, 0, 2, 3), e.tuple)
|
||||
self.assertEqual('POLYGON((0.0 0.0,0.0 3.0,2.0 3.0,2.0 0.0,0.0 0.0))', e.wkt)
|
||||
self.assertEqual('(0.0, 0.0, 2.0, 3.0)', str(e))
|
||||
|
||||
def test03_equivalence(self):
|
||||
"Testing Envelope equivalence."
|
||||
e1 = Envelope(0.523, 0.217, 253.23, 523.69)
|
||||
e2 = Envelope((0.523, 0.217, 253.23, 523.69))
|
||||
self.assertEqual(e1, e2)
|
||||
self.assertEqual((0.523, 0.217, 253.23, 523.69), e1)
|
||||
|
||||
def test04_expand_to_include_pt_2_params(self):
|
||||
"Testing Envelope expand_to_include -- point as two parameters."
|
||||
self.e.expand_to_include(2, 6)
|
||||
self.assertEqual((0, 0, 5, 6), self.e)
|
||||
self.e.expand_to_include(-1, -1)
|
||||
self.assertEqual((-1, -1, 5, 6), self.e)
|
||||
|
||||
def test05_expand_to_include_pt_2_tuple(self):
|
||||
"Testing Envelope expand_to_include -- point as a single 2-tuple parameter."
|
||||
self.e.expand_to_include((10, 10))
|
||||
self.assertEqual((0, 0, 10, 10), self.e)
|
||||
self.e.expand_to_include((-10, -10))
|
||||
self.assertEqual((-10, -10, 10, 10), self.e)
|
||||
|
||||
def test06_expand_to_include_extent_4_params(self):
|
||||
"Testing Envelope expand_to_include -- extent as 4 parameters."
|
||||
self.e.expand_to_include(-1, 1, 3, 7)
|
||||
self.assertEqual((-1, 0, 5, 7), self.e)
|
||||
|
||||
def test06_expand_to_include_extent_4_tuple(self):
|
||||
"Testing Envelope expand_to_include -- extent as a single 4-tuple parameter."
|
||||
self.e.expand_to_include((-1, 1, 3, 7))
|
||||
self.assertEqual((-1, 0, 5, 7), self.e)
|
||||
|
||||
def test07_expand_to_include_envelope(self):
|
||||
"Testing Envelope expand_to_include with Envelope as parameter."
|
||||
self.e.expand_to_include(Envelope(-1, 1, 3, 7))
|
||||
self.assertEqual((-1, 0, 5, 7), self.e)
|
||||
|
||||
def test08_expand_to_include_point(self):
|
||||
"Testing Envelope expand_to_include with Point as parameter."
|
||||
self.e.expand_to_include(TestPoint(-1, 1))
|
||||
self.assertEqual((-1, 0, 5, 5), self.e)
|
||||
self.e.expand_to_include(TestPoint(10, 10))
|
||||
self.assertEqual((-1, 0, 10, 10), self.e)
|
||||
@@ -1,489 +0,0 @@
|
||||
import json
|
||||
import unittest
|
||||
from binascii import b2a_hex
|
||||
from unittest import skipUnless
|
||||
|
||||
from django.contrib.gis.gdal import HAS_GDAL
|
||||
from django.contrib.gis.geometry.test_data import TestDataMixin
|
||||
from django.utils.six.moves import range
|
||||
|
||||
try:
|
||||
from django.utils.six.moves import cPickle as pickle
|
||||
except ImportError:
|
||||
import pickle
|
||||
|
||||
|
||||
if HAS_GDAL:
|
||||
from django.contrib.gis.gdal import (OGRGeometry, OGRGeomType,
|
||||
GDALException, OGRIndexError, SpatialReference, CoordTransform,
|
||||
GDAL_VERSION)
|
||||
|
||||
|
||||
@skipUnless(HAS_GDAL, "GDAL is required")
|
||||
class OGRGeomTest(unittest.TestCase, TestDataMixin):
|
||||
"This tests the OGR Geometry."
|
||||
|
||||
def test00a_geomtype(self):
|
||||
"Testing OGRGeomType object."
|
||||
|
||||
# OGRGeomType should initialize on all these inputs.
|
||||
OGRGeomType(1)
|
||||
OGRGeomType(7)
|
||||
OGRGeomType('point')
|
||||
OGRGeomType('GeometrycollectioN')
|
||||
OGRGeomType('LINearrING')
|
||||
OGRGeomType('Unknown')
|
||||
|
||||
# Should throw TypeError on this input
|
||||
self.assertRaises(GDALException, OGRGeomType, 23)
|
||||
self.assertRaises(GDALException, OGRGeomType, 'fooD')
|
||||
self.assertRaises(GDALException, OGRGeomType, 9)
|
||||
|
||||
# Equivalence can take strings, ints, and other OGRGeomTypes
|
||||
self.assertEqual(OGRGeomType(1), OGRGeomType(1))
|
||||
self.assertEqual(OGRGeomType(7), 'GeometryCollection')
|
||||
self.assertEqual(OGRGeomType('point'), 'POINT')
|
||||
self.assertNotEqual(OGRGeomType('point'), 2)
|
||||
self.assertEqual(OGRGeomType('unknown'), 0)
|
||||
self.assertEqual(OGRGeomType(6), 'MULtiPolyGON')
|
||||
self.assertEqual(OGRGeomType(1), OGRGeomType('point'))
|
||||
self.assertNotEqual(OGRGeomType('POINT'), OGRGeomType(6))
|
||||
|
||||
# Testing the Django field name equivalent property.
|
||||
self.assertEqual('PointField', OGRGeomType('Point').django)
|
||||
self.assertEqual('GeometryField', OGRGeomType('Geometry').django)
|
||||
self.assertEqual('GeometryField', OGRGeomType('Unknown').django)
|
||||
self.assertIsNone(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.assertEqual(OGRGeomType(wkb25bit + 1), 'Point25D')
|
||||
self.assertEqual(OGRGeomType('MultiLineString25D'), (5 + wkb25bit))
|
||||
self.assertEqual('GeometryCollectionField', OGRGeomType('GeometryCollection25D').django)
|
||||
|
||||
def test01a_wkt(self):
|
||||
"Testing WKT output."
|
||||
for g in self.geometries.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 self.geometries.wkt_out:
|
||||
geom = OGRGeometry(g.wkt)
|
||||
exp_gml = g.gml
|
||||
if GDAL_VERSION >= (1, 8):
|
||||
# In GDAL 1.8, the non-conformant GML tag <gml:GeometryCollection> was
|
||||
# replaced with <gml:MultiGeometry>.
|
||||
exp_gml = exp_gml.replace('GeometryCollection', 'MultiGeometry')
|
||||
self.assertEqual(exp_gml, geom.gml)
|
||||
|
||||
def test01c_hex(self):
|
||||
"Testing HEX input/output."
|
||||
for g in self.geometries.hex_wkt:
|
||||
geom1 = OGRGeometry(g.wkt)
|
||||
self.assertEqual(g.hex.encode(), geom1.hex)
|
||||
# Constructing w/HEX
|
||||
geom2 = OGRGeometry(g.hex)
|
||||
self.assertEqual(geom1, geom2)
|
||||
|
||||
def test01d_wkb(self):
|
||||
"Testing WKB input/output."
|
||||
for g in self.geometries.hex_wkt:
|
||||
geom1 = OGRGeometry(g.wkt)
|
||||
wkb = geom1.wkb
|
||||
self.assertEqual(b2a_hex(wkb).upper(), g.hex.encode())
|
||||
# Constructing w/WKB.
|
||||
geom2 = OGRGeometry(wkb)
|
||||
self.assertEqual(geom1, geom2)
|
||||
|
||||
def test01e_json(self):
|
||||
"Testing GeoJSON input/output."
|
||||
for g in self.geometries.json_geoms:
|
||||
geom = OGRGeometry(g.wkt)
|
||||
if not hasattr(g, 'not_equal'):
|
||||
# Loading jsons to prevent decimal differences
|
||||
self.assertEqual(json.loads(g.json), json.loads(geom.json))
|
||||
self.assertEqual(json.loads(g.json), json.loads(geom.geojson))
|
||||
self.assertEqual(OGRGeometry(g.wkt), OGRGeometry(geom.json))
|
||||
# Test input with some garbage content (but valid json) (#15529)
|
||||
geom = OGRGeometry('{"type": "Point", "coordinates": [ 100.0, 0.0 ], "other": "<test>"}')
|
||||
self.assertIsInstance(geom, OGRGeometry)
|
||||
|
||||
def test02_points(self):
|
||||
"Testing Point objects."
|
||||
|
||||
OGRGeometry('POINT(0 0)')
|
||||
for p in self.geometries.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 self.geometries.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.coords, mgeom2.coords)
|
||||
self.assertEqual(mp.n_p, mgeom2.point_count)
|
||||
|
||||
def test04_linestring(self):
|
||||
"Testing LineString objects."
|
||||
prev = OGRGeometry('POINT(0 0)')
|
||||
for ls in self.geometries.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.coords, linestr.tuple)
|
||||
self.assertEqual(linestr, OGRGeometry(ls.wkt))
|
||||
self.assertNotEqual(linestr, prev)
|
||||
self.assertRaises(OGRIndexError, linestr.__getitem__, len(linestr))
|
||||
prev = linestr
|
||||
|
||||
# Testing the x, y properties.
|
||||
x = [tmpx for tmpx, tmpy in ls.coords]
|
||||
y = [tmpy for tmpx, tmpy in ls.coords]
|
||||
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 self.geometries.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.coords, mlinestr.tuple)
|
||||
self.assertEqual(mlinestr, OGRGeometry(mls.wkt))
|
||||
self.assertNotEqual(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 self.geometries.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(lr, OGRGeometry(rr.wkt))
|
||||
self.assertNotEqual(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 self.geometries.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(poly, OGRGeometry(p.wkt))
|
||||
self.assertNotEqual(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)
|
||||
with self.assertRaises(GDALException):
|
||||
poly.centroid
|
||||
|
||||
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."
|
||||
OGRGeometry('POINT(0 0)')
|
||||
for mp in self.geometries.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 self.geometries.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 = OGRGeometry(self.geometries.topology_geoms[0].wkt_a, sr)
|
||||
b = OGRGeometry(self.geometries.topology_geoms[0].wkt_b, 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 multipolygon 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 range(len(self.geometries.topology_geoms)):
|
||||
a = OGRGeometry(self.geometries.topology_geoms[i].wkt_a)
|
||||
b = OGRGeometry(self.geometries.topology_geoms[i].wkt_b)
|
||||
d1 = OGRGeometry(self.geometries.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 range(len(self.geometries.topology_geoms)):
|
||||
a = OGRGeometry(self.geometries.topology_geoms[i].wkt_a)
|
||||
b = OGRGeometry(self.geometries.topology_geoms[i].wkt_b)
|
||||
i1 = OGRGeometry(self.geometries.intersect_geoms[i].wkt)
|
||||
self.assertTrue(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 range(len(self.geometries.topology_geoms)):
|
||||
a = OGRGeometry(self.geometries.topology_geoms[i].wkt_a)
|
||||
b = OGRGeometry(self.geometries.topology_geoms[i].wkt_b)
|
||||
d1 = OGRGeometry(self.geometries.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 range(len(self.geometries.topology_geoms)):
|
||||
a = OGRGeometry(self.geometries.topology_geoms[i].wkt_a)
|
||||
b = OGRGeometry(self.geometries.topology_geoms[i].wkt_b)
|
||||
u1 = OGRGeometry(self.geometries.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(GDALException, 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 self.geometries.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(self.geometries.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."
|
||||
g1 = OGRGeometry('LINESTRING(1 1 1,2 2 2,3 3 3)', 'WGS84')
|
||||
g2 = pickle.loads(pickle.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.assertIsNotNone(OGRGeometry('POINT(0 0)'))
|
||||
self.assertNotEqual(OGRGeometry('LINESTRING(0 0, 1 1)'), 3)
|
||||
@@ -1,118 +0,0 @@
|
||||
"""
|
||||
gdalinfo django/contrib/gis/gdal/tests/data/raster.tif:
|
||||
|
||||
Driver: GTiff/GeoTIFF
|
||||
Files: django/contrib/gis/gdal/tests/data/raster.tif
|
||||
Size is 163, 174
|
||||
Coordinate System is:
|
||||
PROJCS["NAD83 / Florida GDL Albers",
|
||||
GEOGCS["NAD83",
|
||||
DATUM["North_American_Datum_1983",
|
||||
SPHEROID["GRS 1980",6378137,298.2572221010002,
|
||||
AUTHORITY["EPSG","7019"]],
|
||||
TOWGS84[0,0,0,0,0,0,0],
|
||||
AUTHORITY["EPSG","6269"]],
|
||||
PRIMEM["Greenwich",0],
|
||||
UNIT["degree",0.0174532925199433],
|
||||
AUTHORITY["EPSG","4269"]],
|
||||
PROJECTION["Albers_Conic_Equal_Area"],
|
||||
PARAMETER["standard_parallel_1",24],
|
||||
PARAMETER["standard_parallel_2",31.5],
|
||||
PARAMETER["latitude_of_center",24],
|
||||
PARAMETER["longitude_of_center",-84],
|
||||
PARAMETER["false_easting",400000],
|
||||
PARAMETER["false_northing",0],
|
||||
UNIT["metre",1,
|
||||
AUTHORITY["EPSG","9001"]],
|
||||
AUTHORITY["EPSG","3086"]]
|
||||
Origin = (511700.468070655711927,435103.377123198588379)
|
||||
Pixel Size = (100.000000000000000,-100.000000000000000)
|
||||
Metadata:
|
||||
AREA_OR_POINT=Area
|
||||
Image Structure Metadata:
|
||||
INTERLEAVE=BAND
|
||||
Corner Coordinates:
|
||||
Upper Left ( 511700.468, 435103.377) ( 82d51'46.16"W, 27d55' 1.53"N)
|
||||
Lower Left ( 511700.468, 417703.377) ( 82d51'52.04"W, 27d45'37.50"N)
|
||||
Upper Right ( 528000.468, 435103.377) ( 82d41'48.81"W, 27d54'56.30"N)
|
||||
Lower Right ( 528000.468, 417703.377) ( 82d41'55.54"W, 27d45'32.28"N)
|
||||
Center ( 519850.468, 426403.377) ( 82d46'50.64"W, 27d50'16.99"N)
|
||||
Band 1 Block=163x50 Type=Byte, ColorInterp=Gray
|
||||
NoData Value=15
|
||||
"""
|
||||
import os
|
||||
import unittest
|
||||
|
||||
from django.contrib.gis.gdal import HAS_GDAL
|
||||
from django.utils import six
|
||||
from django.utils._os import upath
|
||||
|
||||
if HAS_GDAL:
|
||||
from django.contrib.gis.gdal import GDALRaster
|
||||
from django.contrib.gis.gdal.raster.band import GDALBand
|
||||
|
||||
|
||||
@unittest.skipUnless(HAS_GDAL, "GDAL is required")
|
||||
class GDALRasterTests(unittest.TestCase):
|
||||
"""
|
||||
Test a GDALRaster instance created from a file (GeoTiff).
|
||||
"""
|
||||
def setUp(self):
|
||||
self.rs_path = os.path.join(os.path.dirname(upath(__file__)),
|
||||
'data/raster.tif')
|
||||
self.rs = GDALRaster(self.rs_path)
|
||||
|
||||
def test_rs_name_repr(self):
|
||||
self.assertEqual(self.rs_path, self.rs.name)
|
||||
six.assertRegex(self, repr(self.rs), "<Raster object at 0x\w+>")
|
||||
|
||||
def test_rs_driver(self):
|
||||
self.assertEqual(self.rs.driver.name, 'GTiff')
|
||||
|
||||
def test_rs_size(self):
|
||||
self.assertEqual(self.rs.width, 163)
|
||||
self.assertEqual(self.rs.height, 174)
|
||||
|
||||
def test_rs_srs(self):
|
||||
self.assertEqual(self.rs.srs.srid, 3086)
|
||||
self.assertEqual(self.rs.srs.units, (1.0, 'metre'))
|
||||
|
||||
def test_geotransform_and_friends(self):
|
||||
self.assertEqual(self.rs.geotransform,
|
||||
(511700.4680706557, 100.0, 0.0, 435103.3771231986, 0.0, -100.0))
|
||||
self.assertEqual(self.rs.origin, [511700.4680706557, 435103.3771231986])
|
||||
self.assertEqual(self.rs.origin.x, 511700.4680706557)
|
||||
self.assertEqual(self.rs.origin.y, 435103.3771231986)
|
||||
self.assertEqual(self.rs.scale, [100.0, -100.0])
|
||||
self.assertEqual(self.rs.scale.x, 100.0)
|
||||
self.assertEqual(self.rs.scale.y, -100.0)
|
||||
self.assertEqual(self.rs.skew, [0, 0])
|
||||
self.assertEqual(self.rs.skew.x, 0)
|
||||
self.assertEqual(self.rs.skew.y, 0)
|
||||
|
||||
def test_rs_extent(self):
|
||||
self.assertEqual(self.rs.extent,
|
||||
(511700.4680706557, 417703.3771231986, 528000.4680706557, 435103.3771231986))
|
||||
|
||||
def test_rs_bands(self):
|
||||
self.assertEqual(len(self.rs.bands), 1)
|
||||
self.assertIsInstance(self.rs.bands[0], GDALBand)
|
||||
|
||||
|
||||
@unittest.skipUnless(HAS_GDAL, "GDAL is required")
|
||||
class GDALBandTests(unittest.TestCase):
|
||||
def setUp(self):
|
||||
rs_path = os.path.join(os.path.dirname(upath(__file__)),
|
||||
'data/raster.tif')
|
||||
rs = GDALRaster(rs_path)
|
||||
self.band = rs.bands[0]
|
||||
|
||||
def test_band_data(self):
|
||||
self.assertEqual(self.band.width, 163)
|
||||
self.assertEqual(self.band.height, 174)
|
||||
self.assertEqual(self.band.description, '')
|
||||
self.assertEqual(self.band.datatype(), 1)
|
||||
self.assertEqual(self.band.datatype(as_string=True), 'GDT_Byte')
|
||||
self.assertEqual(self.band.min, 0)
|
||||
self.assertEqual(self.band.max, 255)
|
||||
self.assertEqual(self.band.nodata_value, 15)
|
||||
@@ -1,258 +0,0 @@
|
||||
import unittest
|
||||
from unittest import skipUnless
|
||||
|
||||
from django.contrib.gis.gdal import HAS_GDAL
|
||||
|
||||
if HAS_GDAL:
|
||||
from django.contrib.gis.gdal import SpatialReference, CoordTransform, GDALException, SRSException
|
||||
|
||||
|
||||
class TestSRS:
|
||||
def __init__(self, wkt, **kwargs):
|
||||
self.wkt = wkt
|
||||
for key, value in kwargs.items():
|
||||
setattr(self, key, value)
|
||||
|
||||
# Some Spatial Reference examples
|
||||
srlist = (
|
||||
TestSRS(
|
||||
'GEOGCS["WGS 84",DATUM["WGS_1984",SPHEROID["WGS 84",6378137,298.257223563,'
|
||||
'AUTHORITY["EPSG","7030"]],TOWGS84[0,0,0,0,0,0,0],AUTHORITY["EPSG","6326"]],'
|
||||
'PRIMEM["Greenwich",0,AUTHORITY["EPSG","8901"]],UNIT["degree",'
|
||||
'0.01745329251994328,AUTHORITY["EPSG","9122"]],AUTHORITY["EPSG","4326"]]',
|
||||
proj='+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs ',
|
||||
epsg=4326, projected=False, geographic=True, local=False,
|
||||
lin_name='unknown', ang_name='degree', lin_units=1.0, ang_units=0.0174532925199,
|
||||
auth={'GEOGCS': ('EPSG', '4326'), 'spheroid': ('EPSG', '7030')},
|
||||
attr=(('DATUM', 'WGS_1984'), (('SPHEROID', 1), '6378137'), ('primem|authority', 'EPSG'),),
|
||||
),
|
||||
TestSRS(
|
||||
'PROJCS["NAD83 / Texas South Central",GEOGCS["NAD83",DATUM["North_American_Datum_1983",'
|
||||
'SPHEROID["GRS 1980",6378137,298.257222101,AUTHORITY["EPSG","7019"]],'
|
||||
'AUTHORITY["EPSG","6269"]],PRIMEM["Greenwich",0,AUTHORITY["EPSG","8901"]],'
|
||||
'UNIT["degree",0.01745329251994328,AUTHORITY["EPSG","9122"]],'
|
||||
'AUTHORITY["EPSG","4269"]],PROJECTION["Lambert_Conformal_Conic_2SP"],'
|
||||
'PARAMETER["standard_parallel_1",30.28333333333333],'
|
||||
'PARAMETER["standard_parallel_2",28.38333333333333],'
|
||||
'PARAMETER["latitude_of_origin",27.83333333333333],'
|
||||
'PARAMETER["central_meridian",-99],PARAMETER["false_easting",600000],'
|
||||
'PARAMETER["false_northing",4000000],UNIT["metre",1,AUTHORITY["EPSG","9001"]],'
|
||||
'AUTHORITY["EPSG","32140"]]',
|
||||
proj=None, epsg=32140, projected=True, geographic=False, local=False,
|
||||
lin_name='metre', ang_name='degree', lin_units=1.0, ang_units=0.0174532925199,
|
||||
auth={'PROJCS': ('EPSG', '32140'), 'spheroid': ('EPSG', '7019'), 'unit': ('EPSG', '9001')},
|
||||
attr=(
|
||||
('DATUM', 'North_American_Datum_1983'),
|
||||
(('SPHEROID', 2), '298.257222101'),
|
||||
('PROJECTION', 'Lambert_Conformal_Conic_2SP'),
|
||||
),
|
||||
),
|
||||
TestSRS(
|
||||
'PROJCS["NAD_1983_StatePlane_Texas_South_Central_FIPS_4204_Feet",'
|
||||
'GEOGCS["GCS_North_American_1983",DATUM["North_American_Datum_1983",'
|
||||
'SPHEROID["GRS_1980",6378137.0,298.257222101]],PRIMEM["Greenwich",0.0],'
|
||||
'UNIT["Degree",0.0174532925199433]],PROJECTION["Lambert_Conformal_Conic_2SP"],'
|
||||
'PARAMETER["False_Easting",1968500.0],PARAMETER["False_Northing",13123333.33333333],'
|
||||
'PARAMETER["Central_Meridian",-99.0],PARAMETER["Standard_Parallel_1",28.38333333333333],'
|
||||
'PARAMETER["Standard_Parallel_2",30.28333333333334],PARAMETER["Latitude_Of_Origin",27.83333333333333],'
|
||||
'UNIT["Foot_US",0.3048006096012192]]',
|
||||
proj=None, epsg=None, projected=True, geographic=False, local=False,
|
||||
lin_name='Foot_US', ang_name='Degree', lin_units=0.3048006096012192, ang_units=0.0174532925199,
|
||||
auth={'PROJCS': (None, None)},
|
||||
attr=(('PROJCS|GeOgCs|spheroid', 'GRS_1980'), (('projcs', 9), 'UNIT'), (('projcs', 11), None),),
|
||||
),
|
||||
# This is really ESRI format, not WKT -- but the import should work the same
|
||||
TestSRS(
|
||||
'LOCAL_CS["Non-Earth (Meter)",LOCAL_DATUM["Local Datum",0],UNIT["Meter",1.0],AXIS["X",EAST],AXIS["Y",NORTH]]',
|
||||
esri=True, proj=None, epsg=None, projected=False, geographic=False, local=True,
|
||||
lin_name='Meter', ang_name='degree', lin_units=1.0, ang_units=0.0174532925199,
|
||||
attr=(('LOCAL_DATUM', 'Local Datum'), ('unit', 'Meter')),
|
||||
),
|
||||
)
|
||||
|
||||
# Well-Known Names
|
||||
well_known = (
|
||||
TestSRS(
|
||||
'GEOGCS["WGS 84",DATUM["WGS_1984",SPHEROID["WGS 84",6378137,298.257223563,'
|
||||
'AUTHORITY["EPSG","7030"]],TOWGS84[0,0,0,0,0,0,0],AUTHORITY["EPSG","6326"]],'
|
||||
'PRIMEM["Greenwich",0,AUTHORITY["EPSG","8901"]],UNIT["degree",0.01745329251994328,'
|
||||
'AUTHORITY["EPSG","9122"]],AUTHORITY["EPSG","4326"]]',
|
||||
wk='WGS84', name='WGS 84',
|
||||
attrs=(('GEOGCS|AUTHORITY', 1, '4326'), ('SPHEROID', 'WGS 84')),
|
||||
),
|
||||
TestSRS(
|
||||
'GEOGCS["WGS 72",DATUM["WGS_1972",SPHEROID["WGS 72",6378135,298.26,'
|
||||
'AUTHORITY["EPSG","7043"]],AUTHORITY["EPSG","6322"]],'
|
||||
'PRIMEM["Greenwich",0,AUTHORITY["EPSG","8901"]],'
|
||||
'UNIT["degree",0.01745329251994328,AUTHORITY["EPSG","9122"]],'
|
||||
'AUTHORITY["EPSG","4322"]]',
|
||||
wk='WGS72', name='WGS 72',
|
||||
attrs=(('GEOGCS|AUTHORITY', 1, '4322'), ('SPHEROID', 'WGS 72')),
|
||||
),
|
||||
TestSRS(
|
||||
'GEOGCS["NAD27",DATUM["North_American_Datum_1927",'
|
||||
'SPHEROID["Clarke 1866",6378206.4,294.9786982138982,'
|
||||
'AUTHORITY["EPSG","7008"]],AUTHORITY["EPSG","6267"]],'
|
||||
'PRIMEM["Greenwich",0,AUTHORITY["EPSG","8901"]],'
|
||||
'UNIT["degree",0.01745329251994328,AUTHORITY["EPSG","9122"]],'
|
||||
'AUTHORITY["EPSG","4267"]]',
|
||||
wk='NAD27', name='NAD27',
|
||||
attrs=(('GEOGCS|AUTHORITY', 1, '4267'), ('SPHEROID', 'Clarke 1866'))
|
||||
),
|
||||
TestSRS(
|
||||
'GEOGCS["NAD83",DATUM["North_American_Datum_1983",'
|
||||
'SPHEROID["GRS 1980",6378137,298.257222101,'
|
||||
'AUTHORITY["EPSG","7019"]],AUTHORITY["EPSG","6269"]],'
|
||||
'PRIMEM["Greenwich",0,AUTHORITY["EPSG","8901"]],'
|
||||
'UNIT["degree",0.01745329251994328,AUTHORITY["EPSG","9122"]],'
|
||||
'AUTHORITY["EPSG","4269"]]',
|
||||
wk='NAD83', name='NAD83',
|
||||
attrs=(('GEOGCS|AUTHORITY', 1, '4269'), ('SPHEROID', 'GRS 1980')),
|
||||
),
|
||||
TestSRS(
|
||||
'PROJCS["NZGD49 / Karamea Circuit",GEOGCS["NZGD49",'
|
||||
'DATUM["New_Zealand_Geodetic_Datum_1949",'
|
||||
'SPHEROID["International 1924",6378388,297,'
|
||||
'AUTHORITY["EPSG","7022"]],'
|
||||
'TOWGS84[59.47,-5.04,187.44,0.47,-0.1,1.024,-4.5993],'
|
||||
'AUTHORITY["EPSG","6272"]],PRIMEM["Greenwich",0,'
|
||||
'AUTHORITY["EPSG","8901"]],UNIT["degree",0.01745329251994328,'
|
||||
'AUTHORITY["EPSG","9122"]],AUTHORITY["EPSG","4272"]],'
|
||||
'PROJECTION["Transverse_Mercator"],'
|
||||
'PARAMETER["latitude_of_origin",-41.28991152777778],'
|
||||
'PARAMETER["central_meridian",172.1090281944444],'
|
||||
'PARAMETER["scale_factor",1],PARAMETER["false_easting",300000],'
|
||||
'PARAMETER["false_northing",700000],'
|
||||
'UNIT["metre",1,AUTHORITY["EPSG","9001"]],AUTHORITY["EPSG","27216"]]',
|
||||
wk='EPSG:27216', name='NZGD49 / Karamea Circuit',
|
||||
attrs=(('PROJECTION', 'Transverse_Mercator'), ('SPHEROID', 'International 1924')),
|
||||
),
|
||||
)
|
||||
|
||||
bad_srlist = (
|
||||
'Foobar',
|
||||
'OOJCS["NAD83 / Texas South Central",GEOGCS["NAD83",'
|
||||
'DATUM["North_American_Datum_1983",'
|
||||
'SPHEROID["GRS 1980",6378137,298.257222101,AUTHORITY["EPSG","7019"]],'
|
||||
'AUTHORITY["EPSG","6269"]],PRIMEM["Greenwich",0,AUTHORITY["EPSG","8901"]],'
|
||||
'UNIT["degree",0.01745329251994328,AUTHORITY["EPSG","9122"]],'
|
||||
'AUTHORITY["EPSG","4269"]],PROJECTION["Lambert_Conformal_Conic_2SP"],'
|
||||
'PARAMETER["standard_parallel_1",30.28333333333333],'
|
||||
'PARAMETER["standard_parallel_2",28.38333333333333],'
|
||||
'PARAMETER["latitude_of_origin",27.83333333333333],'
|
||||
'PARAMETER["central_meridian",-99],PARAMETER["false_easting",600000],'
|
||||
'PARAMETER["false_northing",4000000],UNIT["metre",1,'
|
||||
'AUTHORITY["EPSG","9001"]],AUTHORITY["EPSG","32140"]]',
|
||||
)
|
||||
|
||||
|
||||
@skipUnless(HAS_GDAL, "GDAL is required")
|
||||
class SpatialRefTest(unittest.TestCase):
|
||||
|
||||
def test01_wkt(self):
|
||||
"Testing initialization on valid OGC WKT."
|
||||
for s in srlist:
|
||||
SpatialReference(s.wkt)
|
||||
|
||||
def test02_bad_wkt(self):
|
||||
"Testing initialization on invalid WKT."
|
||||
for bad in bad_srlist:
|
||||
try:
|
||||
srs = SpatialReference(bad)
|
||||
srs.validate()
|
||||
except (SRSException, GDALException):
|
||||
pass
|
||||
else:
|
||||
self.fail('Should not have initialized on bad WKT "%s"!')
|
||||
|
||||
def test03_get_wkt(self):
|
||||
"Testing getting the WKT."
|
||||
for s in srlist:
|
||||
srs = SpatialReference(s.wkt)
|
||||
self.assertEqual(s.wkt, srs.wkt)
|
||||
|
||||
def test04_proj(self):
|
||||
"Test PROJ.4 import and export."
|
||||
for s in srlist:
|
||||
if s.proj:
|
||||
srs1 = SpatialReference(s.wkt)
|
||||
srs2 = SpatialReference(s.proj)
|
||||
self.assertEqual(srs1.proj, srs2.proj)
|
||||
|
||||
def test05_epsg(self):
|
||||
"Test EPSG import."
|
||||
for s in srlist:
|
||||
if s.epsg:
|
||||
srs1 = SpatialReference(s.wkt)
|
||||
srs2 = SpatialReference(s.epsg)
|
||||
srs3 = SpatialReference(str(s.epsg))
|
||||
srs4 = SpatialReference('EPSG:%d' % s.epsg)
|
||||
for srs in (srs1, srs2, srs3, srs4):
|
||||
for attr, expected in s.attr:
|
||||
self.assertEqual(expected, srs[attr])
|
||||
|
||||
def test07_boolean_props(self):
|
||||
"Testing the boolean properties."
|
||||
for s in srlist:
|
||||
srs = SpatialReference(s.wkt)
|
||||
self.assertEqual(s.projected, srs.projected)
|
||||
self.assertEqual(s.geographic, srs.geographic)
|
||||
|
||||
def test08_angular_linear(self):
|
||||
"Testing the linear and angular units routines."
|
||||
for s in srlist:
|
||||
srs = SpatialReference(s.wkt)
|
||||
self.assertEqual(s.ang_name, srs.angular_name)
|
||||
self.assertEqual(s.lin_name, srs.linear_name)
|
||||
self.assertAlmostEqual(s.ang_units, srs.angular_units, 9)
|
||||
self.assertAlmostEqual(s.lin_units, srs.linear_units, 9)
|
||||
|
||||
def test09_authority(self):
|
||||
"Testing the authority name & code routines."
|
||||
for s in srlist:
|
||||
if hasattr(s, 'auth'):
|
||||
srs = SpatialReference(s.wkt)
|
||||
for target, tup in s.auth.items():
|
||||
self.assertEqual(tup[0], srs.auth_name(target))
|
||||
self.assertEqual(tup[1], srs.auth_code(target))
|
||||
|
||||
def test10_attributes(self):
|
||||
"Testing the attribute retrieval routines."
|
||||
for s in srlist:
|
||||
srs = SpatialReference(s.wkt)
|
||||
for tup in s.attr:
|
||||
att = tup[0] # Attribute to test
|
||||
exp = tup[1] # Expected result
|
||||
self.assertEqual(exp, srs[att])
|
||||
|
||||
def test11_wellknown(self):
|
||||
"Testing Well Known Names of Spatial References."
|
||||
for s in well_known:
|
||||
srs = SpatialReference(s.wk)
|
||||
self.assertEqual(s.name, srs.name)
|
||||
for tup in s.attrs:
|
||||
if len(tup) == 2:
|
||||
key = tup[0]
|
||||
exp = tup[1]
|
||||
elif len(tup) == 3:
|
||||
key = tup[:2]
|
||||
exp = tup[2]
|
||||
self.assertEqual(srs[key], exp)
|
||||
|
||||
def test12_coordtransform(self):
|
||||
"Testing initialization of a CoordTransform."
|
||||
target = SpatialReference('WGS84')
|
||||
for s in srlist:
|
||||
if s.proj:
|
||||
CoordTransform(SpatialReference(s.wkt), target)
|
||||
|
||||
def test13_attr_value(self):
|
||||
"Testing the attr_value() method."
|
||||
s1 = SpatialReference('WGS84')
|
||||
self.assertRaises(TypeError, s1.__getitem__, 0)
|
||||
self.assertRaises(TypeError, s1.__getitem__, ('GEOGCS', 'foo'))
|
||||
self.assertEqual('WGS 84', s1['GEOGCS'])
|
||||
self.assertEqual('WGS_1984', s1['DATUM'])
|
||||
self.assertEqual('EPSG', s1['AUTHORITY'])
|
||||
self.assertEqual(4326, int(s1['AUTHORITY', 1]))
|
||||
self.assertEqual(None, s1['FOOBAR'])
|
||||
@@ -1,122 +0,0 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
from __future__ import unicode_literals
|
||||
|
||||
import os
|
||||
import unittest
|
||||
from unittest import skipUnless
|
||||
|
||||
from django.conf import settings
|
||||
from django.contrib.gis.geoip import HAS_GEOIP
|
||||
from django.contrib.gis.geos import HAS_GEOS
|
||||
from django.utils import six
|
||||
|
||||
if HAS_GEOIP:
|
||||
from . import GeoIP, GeoIPException
|
||||
|
||||
if HAS_GEOS:
|
||||
from ..geos import GEOSGeometry
|
||||
|
||||
|
||||
# Note: Requires use of both the GeoIP country and city datasets.
|
||||
# The GEOIP_DATA path should be the only setting set (the directory
|
||||
# should contain links or the actual database files 'GeoIP.dat' and
|
||||
# 'GeoLiteCity.dat'.
|
||||
|
||||
|
||||
@skipUnless(HAS_GEOIP and getattr(settings, "GEOIP_PATH", None),
|
||||
"GeoIP is required along with the GEOIP_PATH setting.")
|
||||
class GeoIPTest(unittest.TestCase):
|
||||
|
||||
def test01_init(self):
|
||||
"Testing GeoIP initialization."
|
||||
g1 = GeoIP() # Everything inferred from GeoIP path
|
||||
path = settings.GEOIP_PATH
|
||||
g2 = GeoIP(path, 0) # Passing in data path explicitly.
|
||||
g3 = GeoIP.open(path, 0) # MaxMind Python API syntax.
|
||||
|
||||
for g in (g1, g2, g3):
|
||||
self.assertEqual(True, bool(g._country))
|
||||
self.assertEqual(True, bool(g._city))
|
||||
|
||||
# Only passing in the location of one database.
|
||||
city = os.path.join(path, 'GeoLiteCity.dat')
|
||||
cntry = os.path.join(path, 'GeoIP.dat')
|
||||
g4 = GeoIP(city, country='')
|
||||
self.assertEqual(None, g4._country)
|
||||
g5 = GeoIP(cntry, city='')
|
||||
self.assertEqual(None, g5._city)
|
||||
|
||||
# Improper parameters.
|
||||
bad_params = (23, 'foo', 15.23)
|
||||
for bad in bad_params:
|
||||
self.assertRaises(GeoIPException, GeoIP, cache=bad)
|
||||
if isinstance(bad, six.string_types):
|
||||
e = GeoIPException
|
||||
else:
|
||||
e = TypeError
|
||||
self.assertRaises(e, GeoIP, bad, 0)
|
||||
|
||||
def test02_bad_query(self):
|
||||
"Testing GeoIP query parameter checking."
|
||||
cntry_g = GeoIP(city='<foo>')
|
||||
# No city database available, these calls should fail.
|
||||
self.assertRaises(GeoIPException, cntry_g.city, 'google.com')
|
||||
self.assertRaises(GeoIPException, cntry_g.coords, 'yahoo.com')
|
||||
|
||||
# Non-string query should raise TypeError
|
||||
self.assertRaises(TypeError, cntry_g.country_code, 17)
|
||||
self.assertRaises(TypeError, cntry_g.country_name, GeoIP)
|
||||
|
||||
def test03_country(self):
|
||||
"Testing GeoIP country querying methods."
|
||||
g = GeoIP(city='<foo>')
|
||||
|
||||
fqdn = 'www.google.com'
|
||||
addr = '12.215.42.19'
|
||||
|
||||
for query in (fqdn, addr):
|
||||
for func in (g.country_code, g.country_code_by_addr, g.country_code_by_name):
|
||||
self.assertEqual('US', func(query))
|
||||
for func in (g.country_name, g.country_name_by_addr, g.country_name_by_name):
|
||||
self.assertEqual('United States', func(query))
|
||||
self.assertEqual({'country_code': 'US', 'country_name': 'United States'},
|
||||
g.country(query))
|
||||
|
||||
@skipUnless(HAS_GEOS, "Geos is required")
|
||||
def test04_city(self):
|
||||
"Testing GeoIP city querying methods."
|
||||
g = GeoIP(country='<foo>')
|
||||
|
||||
addr = '128.249.1.1'
|
||||
fqdn = 'tmc.edu'
|
||||
for query in (fqdn, addr):
|
||||
# Country queries should still work.
|
||||
for func in (g.country_code, g.country_code_by_addr, g.country_code_by_name):
|
||||
self.assertEqual('US', func(query))
|
||||
for func in (g.country_name, g.country_name_by_addr, g.country_name_by_name):
|
||||
self.assertEqual('United States', func(query))
|
||||
self.assertEqual({'country_code': 'US', 'country_name': 'United States'},
|
||||
g.country(query))
|
||||
|
||||
# City information dictionary.
|
||||
d = g.city(query)
|
||||
self.assertEqual('USA', d['country_code3'])
|
||||
self.assertEqual('Houston', d['city'])
|
||||
self.assertEqual('TX', d['region'])
|
||||
self.assertEqual(713, d['area_code'])
|
||||
geom = g.geos(query)
|
||||
self.assertIsInstance(geom, GEOSGeometry)
|
||||
lon, lat = (-95.4010, 29.7079)
|
||||
lat_lon = g.lat_lon(query)
|
||||
lat_lon = (lat_lon[1], lat_lon[0])
|
||||
for tup in (geom.tuple, g.coords(query), g.lon_lat(query), lat_lon):
|
||||
self.assertAlmostEqual(lon, tup[0], 4)
|
||||
self.assertAlmostEqual(lat, tup[1], 4)
|
||||
|
||||
def test05_unicode_response(self):
|
||||
"Testing that GeoIP strings are properly encoded, see #16553."
|
||||
g = GeoIP()
|
||||
d = g.city("www.osnabrueck.de")
|
||||
self.assertEqual('Osnabrück', d['city'])
|
||||
d = g.country('200.7.49.81')
|
||||
self.assertEqual('Curaçao', d['country_name'])
|
||||
@@ -1,100 +0,0 @@
|
||||
"""
|
||||
This module has the mock object definitions used to hold reference geometry
|
||||
for the GEOS and GDAL tests.
|
||||
"""
|
||||
import json
|
||||
import os
|
||||
|
||||
from django.contrib import gis
|
||||
from django.utils import six
|
||||
from django.utils._os import upath
|
||||
from django.utils.functional import cached_property
|
||||
|
||||
# Path where reference test data is located.
|
||||
TEST_DATA = os.path.join(os.path.dirname(upath(gis.__file__)), 'tests', 'data')
|
||||
|
||||
|
||||
def tuplize(seq):
|
||||
"Turn all nested sequences to tuples in given sequence."
|
||||
if isinstance(seq, (list, tuple)):
|
||||
return tuple(tuplize(i) for i in seq)
|
||||
return seq
|
||||
|
||||
|
||||
def strconvert(d):
|
||||
"Converts all keys in dictionary to str type."
|
||||
return {str(k): v for k, v in six.iteritems(d)}
|
||||
|
||||
|
||||
def get_ds_file(name, ext):
|
||||
return os.path.join(TEST_DATA,
|
||||
name,
|
||||
name + '.%s' % ext
|
||||
)
|
||||
|
||||
|
||||
class TestObj(object):
|
||||
"""
|
||||
Base testing object, turns keyword args into attributes.
|
||||
"""
|
||||
def __init__(self, **kwargs):
|
||||
for key, value in kwargs.items():
|
||||
setattr(self, key, value)
|
||||
|
||||
|
||||
class TestDS(TestObj):
|
||||
"""
|
||||
Object for testing GDAL data sources.
|
||||
"""
|
||||
def __init__(self, name, **kwargs):
|
||||
# Shapefile is default extension, unless specified otherwise.
|
||||
ext = kwargs.pop('ext', 'shp')
|
||||
self.ds = get_ds_file(name, ext)
|
||||
super(TestDS, self).__init__(**kwargs)
|
||||
|
||||
|
||||
class TestGeom(TestObj):
|
||||
"""
|
||||
Testing object used for wrapping reference geometry data
|
||||
in GEOS/GDAL tests.
|
||||
"""
|
||||
def __init__(self, **kwargs):
|
||||
# Converting lists to tuples of certain keyword args
|
||||
# so coordinate test cases will match (JSON has no
|
||||
# concept of tuple).
|
||||
coords = kwargs.pop('coords', None)
|
||||
if coords:
|
||||
self.coords = tuplize(coords)
|
||||
|
||||
centroid = kwargs.pop('centroid', None)
|
||||
if centroid:
|
||||
self.centroid = tuple(centroid)
|
||||
|
||||
ext_ring_cs = kwargs.pop('ext_ring_cs', None)
|
||||
if ext_ring_cs:
|
||||
ext_ring_cs = tuplize(ext_ring_cs)
|
||||
self.ext_ring_cs = ext_ring_cs
|
||||
|
||||
super(TestGeom, self).__init__(**kwargs)
|
||||
|
||||
|
||||
class TestGeomSet(object):
|
||||
"""
|
||||
Each attribute of this object is a list of `TestGeom` instances.
|
||||
"""
|
||||
def __init__(self, **kwargs):
|
||||
for key, value in kwargs.items():
|
||||
setattr(self, key, [TestGeom(**strconvert(kw)) for kw in value])
|
||||
|
||||
|
||||
class TestDataMixin(object):
|
||||
"""
|
||||
Mixin used for GEOS/GDAL test cases that defines a `geometries`
|
||||
property, which returns and/or loads the reference geometry data.
|
||||
"""
|
||||
@cached_property
|
||||
def geometries(self):
|
||||
# Load up the test geometry data from fixture into global.
|
||||
with open(os.path.join(TEST_DATA, 'geometries.json')) as f:
|
||||
geometries = json.load(f)
|
||||
return TestGeomSet(**strconvert(geometries))
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,171 +0,0 @@
|
||||
# Copyright (c) 2008-2009 Aryeh Leib Taurog, all rights reserved.
|
||||
# Modified from original contribution by Aryeh Leib Taurog, which was
|
||||
# released under the New BSD license.
|
||||
|
||||
import unittest
|
||||
from unittest import skipUnless
|
||||
|
||||
from .. import HAS_GEOS
|
||||
|
||||
if HAS_GEOS:
|
||||
from .. import fromstr, LinearRing, LineString, MultiPoint, Point, Polygon
|
||||
from ..error import GEOSIndexError
|
||||
|
||||
|
||||
if HAS_GEOS:
|
||||
def api_get_distance(x):
|
||||
return x.distance(Point(-200, -200))
|
||||
|
||||
|
||||
def api_get_buffer(x):
|
||||
return x.buffer(10)
|
||||
|
||||
|
||||
def api_get_geom_typeid(x):
|
||||
return x.geom_typeid
|
||||
|
||||
|
||||
def api_get_num_coords(x):
|
||||
return x.num_coords
|
||||
|
||||
|
||||
def api_get_centroid(x):
|
||||
return x.centroid
|
||||
|
||||
|
||||
def api_get_empty(x):
|
||||
return x.empty
|
||||
|
||||
|
||||
def api_get_valid(x):
|
||||
return x.valid
|
||||
|
||||
|
||||
def api_get_simple(x):
|
||||
return x.simple
|
||||
|
||||
|
||||
def api_get_ring(x):
|
||||
return x.ring
|
||||
|
||||
|
||||
def api_get_boundary(x):
|
||||
return x.boundary
|
||||
|
||||
|
||||
def api_get_convex_hull(x):
|
||||
return x.convex_hull
|
||||
|
||||
|
||||
def api_get_extent(x):
|
||||
return x.extent
|
||||
|
||||
|
||||
def api_get_area(x):
|
||||
return x.area
|
||||
|
||||
|
||||
def api_get_length(x):
|
||||
return x.length
|
||||
|
||||
geos_function_tests = [val for name, val in vars().items()
|
||||
if hasattr(val, '__call__')
|
||||
and name.startswith('api_get_')]
|
||||
|
||||
|
||||
@skipUnless(HAS_GEOS, "Geos is required.")
|
||||
class GEOSMutationTest(unittest.TestCase):
|
||||
"""
|
||||
Tests Pythonic Mutability of Python GEOS geometry wrappers
|
||||
get/set/delitem on a slice, normal list methods
|
||||
"""
|
||||
|
||||
def test00_GEOSIndexException(self):
|
||||
'Testing Geometry GEOSIndexError'
|
||||
p = Point(1, 2)
|
||||
for i in range(-2, 2):
|
||||
p._checkindex(i)
|
||||
self.assertRaises(GEOSIndexError, p._checkindex, 2)
|
||||
self.assertRaises(GEOSIndexError, p._checkindex, -3)
|
||||
|
||||
def test01_PointMutations(self):
|
||||
'Testing Point mutations'
|
||||
for p in (Point(1, 2, 3), fromstr('POINT (1 2 3)')):
|
||||
self.assertEqual(p._get_single_external(1), 2.0, 'Point _get_single_external')
|
||||
|
||||
# _set_single
|
||||
p._set_single(0, 100)
|
||||
self.assertEqual(p.coords, (100.0, 2.0, 3.0), 'Point _set_single')
|
||||
|
||||
# _set_list
|
||||
p._set_list(2, (50, 3141))
|
||||
self.assertEqual(p.coords, (50.0, 3141.0), 'Point _set_list')
|
||||
|
||||
def test02_PointExceptions(self):
|
||||
'Testing Point exceptions'
|
||||
self.assertRaises(TypeError, Point, range(1))
|
||||
self.assertRaises(TypeError, Point, range(4))
|
||||
|
||||
def test03_PointApi(self):
|
||||
'Testing Point API'
|
||||
q = Point(4, 5, 3)
|
||||
for p in (Point(1, 2, 3), fromstr('POINT (1 2 3)')):
|
||||
p[0:2] = [4, 5]
|
||||
for f in geos_function_tests:
|
||||
self.assertEqual(f(q), f(p), 'Point ' + f.__name__)
|
||||
|
||||
def test04_LineStringMutations(self):
|
||||
'Testing LineString mutations'
|
||||
for ls in (LineString((1, 0), (4, 1), (6, -1)),
|
||||
fromstr('LINESTRING (1 0,4 1,6 -1)')):
|
||||
self.assertEqual(ls._get_single_external(1), (4.0, 1.0), 'LineString _get_single_external')
|
||||
|
||||
# _set_single
|
||||
ls._set_single(0, (-50, 25))
|
||||
self.assertEqual(ls.coords, ((-50.0, 25.0), (4.0, 1.0), (6.0, -1.0)), 'LineString _set_single')
|
||||
|
||||
# _set_list
|
||||
ls._set_list(2, ((-50.0, 25.0), (6.0, -1.0)))
|
||||
self.assertEqual(ls.coords, ((-50.0, 25.0), (6.0, -1.0)), 'LineString _set_list')
|
||||
|
||||
lsa = LineString(ls.coords)
|
||||
for f in geos_function_tests:
|
||||
self.assertEqual(f(lsa), f(ls), 'LineString ' + f.__name__)
|
||||
|
||||
def test05_Polygon(self):
|
||||
'Testing Polygon mutations'
|
||||
for pg in (Polygon(((1, 0), (4, 1), (6, -1), (8, 10), (1, 0)),
|
||||
((5, 4), (6, 4), (6, 3), (5, 4))),
|
||||
fromstr('POLYGON ((1 0,4 1,6 -1,8 10,1 0),(5 4,6 4,6 3,5 4))')):
|
||||
self.assertEqual(pg._get_single_external(0),
|
||||
LinearRing((1, 0), (4, 1), (6, -1), (8, 10), (1, 0)),
|
||||
'Polygon _get_single_external(0)')
|
||||
self.assertEqual(pg._get_single_external(1),
|
||||
LinearRing((5, 4), (6, 4), (6, 3), (5, 4)),
|
||||
'Polygon _get_single_external(1)')
|
||||
|
||||
# _set_list
|
||||
pg._set_list(2, (((1, 2), (10, 0), (12, 9), (-1, 15), (1, 2)),
|
||||
((4, 2), (5, 2), (5, 3), (4, 2))))
|
||||
self.assertEqual(
|
||||
pg.coords,
|
||||
(((1.0, 2.0), (10.0, 0.0), (12.0, 9.0), (-1.0, 15.0), (1.0, 2.0)),
|
||||
((4.0, 2.0), (5.0, 2.0), (5.0, 3.0), (4.0, 2.0))),
|
||||
'Polygon _set_list')
|
||||
|
||||
lsa = Polygon(*pg.coords)
|
||||
for f in geos_function_tests:
|
||||
self.assertEqual(f(lsa), f(pg), 'Polygon ' + f.__name__)
|
||||
|
||||
def test06_Collection(self):
|
||||
'Testing Collection mutations'
|
||||
for mp in (MultiPoint(*map(Point, ((3, 4), (-1, 2), (5, -4), (2, 8)))),
|
||||
fromstr('MULTIPOINT (3 4,-1 2,5 -4,2 8)')):
|
||||
self.assertEqual(mp._get_single_external(2), Point(5, -4), 'Collection _get_single_external')
|
||||
|
||||
mp._set_list(3, map(Point, ((5, 5), (3, -2), (8, 1))))
|
||||
self.assertEqual(mp.coords, ((5.0, 5.0), (3.0, -2.0), (8.0, 1.0)), 'Collection _set_list')
|
||||
|
||||
lsa = MultiPoint(*map(Point, ((5, 5), (3, -2), (8, 1))))
|
||||
for f in geos_function_tests:
|
||||
self.assertEqual(f(lsa), f(mp), 'MultiPoint ' + f.__name__)
|
||||
@@ -1,113 +0,0 @@
|
||||
from __future__ import unicode_literals
|
||||
|
||||
import binascii
|
||||
import unittest
|
||||
from unittest import skipUnless
|
||||
|
||||
from django.utils.six import memoryview
|
||||
|
||||
from ..import HAS_GEOS # isort:skip
|
||||
|
||||
if HAS_GEOS:
|
||||
from .. import GEOSGeometry, WKTReader, WKTWriter, WKBReader, WKBWriter
|
||||
|
||||
|
||||
@skipUnless(HAS_GEOS, "Geos is required.")
|
||||
class GEOSIOTest(unittest.TestCase):
|
||||
|
||||
def test01_wktreader(self):
|
||||
# Creating a WKTReader instance
|
||||
wkt_r = WKTReader()
|
||||
wkt = 'POINT (5 23)'
|
||||
|
||||
# read() should return a GEOSGeometry
|
||||
ref = GEOSGeometry(wkt)
|
||||
g1 = wkt_r.read(wkt.encode())
|
||||
g2 = wkt_r.read(wkt)
|
||||
|
||||
for geom in (g1, g2):
|
||||
self.assertEqual(ref, geom)
|
||||
|
||||
# Should only accept six.string_types objects.
|
||||
self.assertRaises(TypeError, wkt_r.read, 1)
|
||||
self.assertRaises(TypeError, wkt_r.read, memoryview(b'foo'))
|
||||
|
||||
def test02_wktwriter(self):
|
||||
# Creating a WKTWriter instance, testing its ptr property.
|
||||
wkt_w = WKTWriter()
|
||||
self.assertRaises(TypeError, wkt_w._set_ptr, WKTReader.ptr_type())
|
||||
|
||||
ref = GEOSGeometry('POINT (5 23)')
|
||||
ref_wkt = 'POINT (5.0000000000000000 23.0000000000000000)'
|
||||
self.assertEqual(ref_wkt, wkt_w.write(ref).decode())
|
||||
|
||||
def test03_wkbreader(self):
|
||||
# Creating a WKBReader instance
|
||||
wkb_r = WKBReader()
|
||||
|
||||
hex = b'000000000140140000000000004037000000000000'
|
||||
wkb = memoryview(binascii.a2b_hex(hex))
|
||||
ref = GEOSGeometry(hex)
|
||||
|
||||
# read() should return a GEOSGeometry on either a hex string or
|
||||
# a WKB buffer.
|
||||
g1 = wkb_r.read(wkb)
|
||||
g2 = wkb_r.read(hex)
|
||||
for geom in (g1, g2):
|
||||
self.assertEqual(ref, geom)
|
||||
|
||||
bad_input = (1, 5.23, None, False)
|
||||
for bad_wkb in bad_input:
|
||||
self.assertRaises(TypeError, wkb_r.read, bad_wkb)
|
||||
|
||||
def test04_wkbwriter(self):
|
||||
wkb_w = WKBWriter()
|
||||
|
||||
# Representations of 'POINT (5 23)' in hex -- one normal and
|
||||
# the other with the byte order changed.
|
||||
g = GEOSGeometry('POINT (5 23)')
|
||||
hex1 = b'010100000000000000000014400000000000003740'
|
||||
wkb1 = memoryview(binascii.a2b_hex(hex1))
|
||||
hex2 = b'000000000140140000000000004037000000000000'
|
||||
wkb2 = memoryview(binascii.a2b_hex(hex2))
|
||||
|
||||
self.assertEqual(hex1, wkb_w.write_hex(g))
|
||||
self.assertEqual(wkb1, wkb_w.write(g))
|
||||
|
||||
# Ensuring bad byteorders are not accepted.
|
||||
for bad_byteorder in (-1, 2, 523, 'foo', None):
|
||||
# Equivalent of `wkb_w.byteorder = bad_byteorder`
|
||||
self.assertRaises(ValueError, wkb_w._set_byteorder, bad_byteorder)
|
||||
|
||||
# Setting the byteorder to 0 (for Big Endian)
|
||||
wkb_w.byteorder = 0
|
||||
self.assertEqual(hex2, wkb_w.write_hex(g))
|
||||
self.assertEqual(wkb2, wkb_w.write(g))
|
||||
|
||||
# Back to Little Endian
|
||||
wkb_w.byteorder = 1
|
||||
|
||||
# Now, trying out the 3D and SRID flags.
|
||||
g = GEOSGeometry('POINT (5 23 17)')
|
||||
g.srid = 4326
|
||||
|
||||
hex3d = b'0101000080000000000000144000000000000037400000000000003140'
|
||||
wkb3d = memoryview(binascii.a2b_hex(hex3d))
|
||||
hex3d_srid = b'01010000A0E6100000000000000000144000000000000037400000000000003140'
|
||||
wkb3d_srid = memoryview(binascii.a2b_hex(hex3d_srid))
|
||||
|
||||
# Ensuring bad output dimensions are not accepted
|
||||
for bad_outdim in (-1, 0, 1, 4, 423, 'foo', None):
|
||||
# Equivalent of `wkb_w.outdim = bad_outdim`
|
||||
self.assertRaises(ValueError, wkb_w._set_outdim, bad_outdim)
|
||||
|
||||
# Now setting the output dimensions to be 3
|
||||
wkb_w.outdim = 3
|
||||
|
||||
self.assertEqual(hex3d, wkb_w.write_hex(g))
|
||||
self.assertEqual(wkb3d, wkb_w.write(g))
|
||||
|
||||
# Telling the WKBWriter to include the srid in the representation.
|
||||
wkb_w.srid = True
|
||||
self.assertEqual(hex3d_srid, wkb_w.write_hex(g))
|
||||
self.assertEqual(wkb3d_srid, wkb_w.write(g))
|
||||
@@ -1,425 +0,0 @@
|
||||
# Copyright (c) 2008-2009 Aryeh Leib Taurog, http://www.aryehleib.com
|
||||
# All rights reserved.
|
||||
#
|
||||
# Modified from original contribution by Aryeh Leib Taurog, which was
|
||||
# released under the New BSD license.
|
||||
|
||||
import unittest
|
||||
|
||||
from django.contrib.gis.geos.mutable_list import ListMixin
|
||||
from django.utils import six
|
||||
|
||||
|
||||
class UserListA(ListMixin):
|
||||
_mytype = tuple
|
||||
|
||||
def __init__(self, i_list, *args, **kwargs):
|
||||
self._list = self._mytype(i_list)
|
||||
super(UserListA, self).__init__(*args, **kwargs)
|
||||
|
||||
def __len__(self):
|
||||
return len(self._list)
|
||||
|
||||
def __str__(self):
|
||||
return str(self._list)
|
||||
|
||||
def __repr__(self):
|
||||
return repr(self._list)
|
||||
|
||||
def _set_list(self, length, items):
|
||||
# this would work:
|
||||
# self._list = self._mytype(items)
|
||||
# but then we wouldn't be testing length parameter
|
||||
itemList = ['x'] * length
|
||||
for i, v in enumerate(items):
|
||||
itemList[i] = v
|
||||
|
||||
self._list = self._mytype(itemList)
|
||||
|
||||
def _get_single_external(self, index):
|
||||
return self._list[index]
|
||||
|
||||
|
||||
class UserListB(UserListA):
|
||||
_mytype = list
|
||||
|
||||
def _set_single(self, index, value):
|
||||
self._list[index] = value
|
||||
|
||||
|
||||
def nextRange(length):
|
||||
nextRange.start += 100
|
||||
return range(nextRange.start, nextRange.start + length)
|
||||
|
||||
nextRange.start = 0
|
||||
|
||||
|
||||
class ListMixinTest(unittest.TestCase):
|
||||
"""
|
||||
Tests base class ListMixin by comparing a list clone which is
|
||||
a ListMixin subclass with a real Python list.
|
||||
"""
|
||||
limit = 3
|
||||
listType = UserListA
|
||||
|
||||
def lists_of_len(self, length=None):
|
||||
if length is None:
|
||||
length = self.limit
|
||||
pl = list(range(length))
|
||||
return pl, self.listType(pl)
|
||||
|
||||
def limits_plus(self, b):
|
||||
return range(-self.limit - b, self.limit + b)
|
||||
|
||||
def step_range(self):
|
||||
return list(range(-1 - self.limit, 0)) + list(range(1, 1 + self.limit))
|
||||
|
||||
def test01_getslice(self):
|
||||
'Slice retrieval'
|
||||
pl, ul = self.lists_of_len()
|
||||
for i in self.limits_plus(1):
|
||||
self.assertEqual(pl[i:], ul[i:], 'slice [%d:]' % (i))
|
||||
self.assertEqual(pl[:i], ul[:i], 'slice [:%d]' % (i))
|
||||
|
||||
for j in self.limits_plus(1):
|
||||
self.assertEqual(pl[i:j], ul[i:j], 'slice [%d:%d]' % (i, j))
|
||||
for k in self.step_range():
|
||||
self.assertEqual(pl[i:j:k], ul[i:j:k], 'slice [%d:%d:%d]' % (i, j, k))
|
||||
|
||||
for k in self.step_range():
|
||||
self.assertEqual(pl[i::k], ul[i::k], 'slice [%d::%d]' % (i, k))
|
||||
self.assertEqual(pl[:i:k], ul[:i:k], 'slice [:%d:%d]' % (i, k))
|
||||
|
||||
for k in self.step_range():
|
||||
self.assertEqual(pl[::k], ul[::k], 'slice [::%d]' % (k))
|
||||
|
||||
def test02_setslice(self):
|
||||
'Slice assignment'
|
||||
def setfcn(x, i, j, k, L):
|
||||
x[i:j:k] = range(L)
|
||||
pl, ul = self.lists_of_len()
|
||||
for slen in range(self.limit + 1):
|
||||
ssl = nextRange(slen)
|
||||
ul[:] = ssl
|
||||
pl[:] = ssl
|
||||
self.assertEqual(pl, ul[:], 'set slice [:]')
|
||||
|
||||
for i in self.limits_plus(1):
|
||||
ssl = nextRange(slen)
|
||||
ul[i:] = ssl
|
||||
pl[i:] = ssl
|
||||
self.assertEqual(pl, ul[:], 'set slice [%d:]' % (i))
|
||||
|
||||
ssl = nextRange(slen)
|
||||
ul[:i] = ssl
|
||||
pl[:i] = ssl
|
||||
self.assertEqual(pl, ul[:], 'set slice [:%d]' % (i))
|
||||
|
||||
for j in self.limits_plus(1):
|
||||
ssl = nextRange(slen)
|
||||
ul[i:j] = ssl
|
||||
pl[i:j] = ssl
|
||||
self.assertEqual(pl, ul[:], 'set slice [%d:%d]' % (i, j))
|
||||
|
||||
for k in self.step_range():
|
||||
ssl = nextRange(len(ul[i:j:k]))
|
||||
ul[i:j:k] = ssl
|
||||
pl[i:j:k] = ssl
|
||||
self.assertEqual(pl, ul[:], 'set slice [%d:%d:%d]' % (i, j, k))
|
||||
|
||||
sliceLen = len(ul[i:j:k])
|
||||
self.assertRaises(ValueError, setfcn, ul, i, j, k, sliceLen + 1)
|
||||
if sliceLen > 2:
|
||||
self.assertRaises(ValueError, setfcn, ul, i, j, k, sliceLen - 1)
|
||||
|
||||
for k in self.step_range():
|
||||
ssl = nextRange(len(ul[i::k]))
|
||||
ul[i::k] = ssl
|
||||
pl[i::k] = ssl
|
||||
self.assertEqual(pl, ul[:], 'set slice [%d::%d]' % (i, k))
|
||||
|
||||
ssl = nextRange(len(ul[:i:k]))
|
||||
ul[:i:k] = ssl
|
||||
pl[:i:k] = ssl
|
||||
self.assertEqual(pl, ul[:], 'set slice [:%d:%d]' % (i, k))
|
||||
|
||||
for k in self.step_range():
|
||||
ssl = nextRange(len(ul[::k]))
|
||||
ul[::k] = ssl
|
||||
pl[::k] = ssl
|
||||
self.assertEqual(pl, ul[:], 'set slice [::%d]' % (k))
|
||||
|
||||
def test03_delslice(self):
|
||||
'Delete slice'
|
||||
for Len in range(self.limit):
|
||||
pl, ul = self.lists_of_len(Len)
|
||||
del pl[:]
|
||||
del ul[:]
|
||||
self.assertEqual(pl[:], ul[:], 'del slice [:]')
|
||||
for i in range(-Len - 1, Len + 1):
|
||||
pl, ul = self.lists_of_len(Len)
|
||||
del pl[i:]
|
||||
del ul[i:]
|
||||
self.assertEqual(pl[:], ul[:], 'del slice [%d:]' % (i))
|
||||
pl, ul = self.lists_of_len(Len)
|
||||
del pl[:i]
|
||||
del ul[:i]
|
||||
self.assertEqual(pl[:], ul[:], 'del slice [:%d]' % (i))
|
||||
for j in range(-Len - 1, Len + 1):
|
||||
pl, ul = self.lists_of_len(Len)
|
||||
del pl[i:j]
|
||||
del ul[i:j]
|
||||
self.assertEqual(pl[:], ul[:], 'del slice [%d:%d]' % (i, j))
|
||||
for k in list(range(-Len - 1, 0)) + list(range(1, Len)):
|
||||
pl, ul = self.lists_of_len(Len)
|
||||
del pl[i:j:k]
|
||||
del ul[i:j:k]
|
||||
self.assertEqual(pl[:], ul[:], 'del slice [%d:%d:%d]' % (i, j, k))
|
||||
|
||||
for k in list(range(-Len - 1, 0)) + list(range(1, Len)):
|
||||
pl, ul = self.lists_of_len(Len)
|
||||
del pl[:i:k]
|
||||
del ul[:i:k]
|
||||
self.assertEqual(pl[:], ul[:], 'del slice [:%d:%d]' % (i, k))
|
||||
|
||||
pl, ul = self.lists_of_len(Len)
|
||||
del pl[i::k]
|
||||
del ul[i::k]
|
||||
self.assertEqual(pl[:], ul[:], 'del slice [%d::%d]' % (i, k))
|
||||
|
||||
for k in list(range(-Len - 1, 0)) + list(range(1, Len)):
|
||||
pl, ul = self.lists_of_len(Len)
|
||||
del pl[::k]
|
||||
del ul[::k]
|
||||
self.assertEqual(pl[:], ul[:], 'del slice [::%d]' % (k))
|
||||
|
||||
def test04_get_set_del_single(self):
|
||||
'Get/set/delete single item'
|
||||
pl, ul = self.lists_of_len()
|
||||
for i in self.limits_plus(0):
|
||||
self.assertEqual(pl[i], ul[i], 'get single item [%d]' % i)
|
||||
|
||||
for i in self.limits_plus(0):
|
||||
pl, ul = self.lists_of_len()
|
||||
pl[i] = 100
|
||||
ul[i] = 100
|
||||
self.assertEqual(pl[:], ul[:], 'set single item [%d]' % i)
|
||||
|
||||
for i in self.limits_plus(0):
|
||||
pl, ul = self.lists_of_len()
|
||||
del pl[i]
|
||||
del ul[i]
|
||||
self.assertEqual(pl[:], ul[:], 'del single item [%d]' % i)
|
||||
|
||||
def test05_out_of_range_exceptions(self):
|
||||
'Out of range exceptions'
|
||||
def setfcn(x, i):
|
||||
x[i] = 20
|
||||
|
||||
def getfcn(x, i):
|
||||
return x[i]
|
||||
|
||||
def delfcn(x, i):
|
||||
del x[i]
|
||||
pl, ul = self.lists_of_len()
|
||||
for i in (-1 - self.limit, self.limit):
|
||||
self.assertRaises(IndexError, setfcn, ul, i) # 'set index %d' % i)
|
||||
self.assertRaises(IndexError, getfcn, ul, i) # 'get index %d' % i)
|
||||
self.assertRaises(IndexError, delfcn, ul, i) # 'del index %d' % i)
|
||||
|
||||
def test06_list_methods(self):
|
||||
'List methods'
|
||||
pl, ul = self.lists_of_len()
|
||||
pl.append(40)
|
||||
ul.append(40)
|
||||
self.assertEqual(pl[:], ul[:], 'append')
|
||||
|
||||
pl.extend(range(50, 55))
|
||||
ul.extend(range(50, 55))
|
||||
self.assertEqual(pl[:], ul[:], 'extend')
|
||||
|
||||
pl.reverse()
|
||||
ul.reverse()
|
||||
self.assertEqual(pl[:], ul[:], 'reverse')
|
||||
|
||||
for i in self.limits_plus(1):
|
||||
pl, ul = self.lists_of_len()
|
||||
pl.insert(i, 50)
|
||||
ul.insert(i, 50)
|
||||
self.assertEqual(pl[:], ul[:], 'insert at %d' % i)
|
||||
|
||||
for i in self.limits_plus(0):
|
||||
pl, ul = self.lists_of_len()
|
||||
self.assertEqual(pl.pop(i), ul.pop(i), 'popped value at %d' % i)
|
||||
self.assertEqual(pl[:], ul[:], 'after pop at %d' % i)
|
||||
|
||||
pl, ul = self.lists_of_len()
|
||||
self.assertEqual(pl.pop(), ul.pop(i), 'popped value')
|
||||
self.assertEqual(pl[:], ul[:], 'after pop')
|
||||
|
||||
pl, ul = self.lists_of_len()
|
||||
|
||||
def popfcn(x, i):
|
||||
x.pop(i)
|
||||
self.assertRaises(IndexError, popfcn, ul, self.limit)
|
||||
self.assertRaises(IndexError, popfcn, ul, -1 - self.limit)
|
||||
|
||||
pl, ul = self.lists_of_len()
|
||||
for val in range(self.limit):
|
||||
self.assertEqual(pl.index(val), ul.index(val), 'index of %d' % val)
|
||||
|
||||
for val in self.limits_plus(2):
|
||||
self.assertEqual(pl.count(val), ul.count(val), 'count %d' % val)
|
||||
|
||||
for val in range(self.limit):
|
||||
pl, ul = self.lists_of_len()
|
||||
pl.remove(val)
|
||||
ul.remove(val)
|
||||
self.assertEqual(pl[:], ul[:], 'after remove val %d' % val)
|
||||
|
||||
def indexfcn(x, v):
|
||||
return x.index(v)
|
||||
|
||||
def removefcn(x, v):
|
||||
return x.remove(v)
|
||||
self.assertRaises(ValueError, indexfcn, ul, 40)
|
||||
self.assertRaises(ValueError, removefcn, ul, 40)
|
||||
|
||||
def test07_allowed_types(self):
|
||||
'Type-restricted list'
|
||||
pl, ul = self.lists_of_len()
|
||||
ul._allowed = six.integer_types
|
||||
ul[1] = 50
|
||||
ul[:2] = [60, 70, 80]
|
||||
|
||||
def setfcn(x, i, v):
|
||||
x[i] = v
|
||||
self.assertRaises(TypeError, setfcn, ul, 2, 'hello')
|
||||
self.assertRaises(TypeError, setfcn, ul, slice(0, 3, 2), ('hello', 'goodbye'))
|
||||
|
||||
def test08_min_length(self):
|
||||
'Length limits'
|
||||
pl, ul = self.lists_of_len()
|
||||
ul._minlength = 1
|
||||
|
||||
def delfcn(x, i):
|
||||
del x[:i]
|
||||
|
||||
def setfcn(x, i):
|
||||
x[:i] = []
|
||||
for i in range(self.limit - ul._minlength + 1, self.limit + 1):
|
||||
self.assertRaises(ValueError, delfcn, ul, i)
|
||||
self.assertRaises(ValueError, setfcn, ul, i)
|
||||
del ul[:ul._minlength]
|
||||
|
||||
ul._maxlength = 4
|
||||
for i in range(0, ul._maxlength - len(ul)):
|
||||
ul.append(i)
|
||||
self.assertRaises(ValueError, ul.append, 10)
|
||||
|
||||
def test09_iterable_check(self):
|
||||
'Error on assigning non-iterable to slice'
|
||||
pl, ul = self.lists_of_len(self.limit + 1)
|
||||
|
||||
def setfcn(x, i, v):
|
||||
x[i] = v
|
||||
self.assertRaises(TypeError, setfcn, ul, slice(0, 3, 2), 2)
|
||||
|
||||
def test10_checkindex(self):
|
||||
'Index check'
|
||||
pl, ul = self.lists_of_len()
|
||||
for i in self.limits_plus(0):
|
||||
if i < 0:
|
||||
self.assertEqual(ul._checkindex(i), i + self.limit, '_checkindex(neg index)')
|
||||
else:
|
||||
self.assertEqual(ul._checkindex(i), i, '_checkindex(pos index)')
|
||||
|
||||
for i in (-self.limit - 1, self.limit):
|
||||
self.assertRaises(IndexError, ul._checkindex, i)
|
||||
|
||||
ul._IndexError = TypeError
|
||||
self.assertRaises(TypeError, ul._checkindex, -self.limit - 1)
|
||||
|
||||
def test_11_sorting(self):
|
||||
'Sorting'
|
||||
pl, ul = self.lists_of_len()
|
||||
pl.insert(0, pl.pop())
|
||||
ul.insert(0, ul.pop())
|
||||
pl.sort()
|
||||
ul.sort()
|
||||
self.assertEqual(pl[:], ul[:], 'sort')
|
||||
mid = pl[len(pl) // 2]
|
||||
pl.sort(key=lambda x: (mid - x) ** 2)
|
||||
ul.sort(key=lambda x: (mid - x) ** 2)
|
||||
self.assertEqual(pl[:], ul[:], 'sort w/ key')
|
||||
|
||||
pl.insert(0, pl.pop())
|
||||
ul.insert(0, ul.pop())
|
||||
pl.sort(reverse=True)
|
||||
ul.sort(reverse=True)
|
||||
self.assertEqual(pl[:], ul[:], 'sort w/ reverse')
|
||||
mid = pl[len(pl) // 2]
|
||||
pl.sort(key=lambda x: (mid - x) ** 2)
|
||||
ul.sort(key=lambda x: (mid - x) ** 2)
|
||||
self.assertEqual(pl[:], ul[:], 'sort w/ key')
|
||||
|
||||
def test_12_arithmetic(self):
|
||||
'Arithmetic'
|
||||
pl, ul = self.lists_of_len()
|
||||
al = list(range(10, 14))
|
||||
self.assertEqual(list(pl + al), list(ul + al), 'add')
|
||||
self.assertEqual(type(ul), type(ul + al), 'type of add result')
|
||||
self.assertEqual(list(al + pl), list(al + ul), 'radd')
|
||||
self.assertEqual(type(al), type(al + ul), 'type of radd result')
|
||||
objid = id(ul)
|
||||
pl += al
|
||||
ul += al
|
||||
self.assertEqual(pl[:], ul[:], 'in-place add')
|
||||
self.assertEqual(objid, id(ul), 'in-place add id')
|
||||
|
||||
for n in (-1, 0, 1, 3):
|
||||
pl, ul = self.lists_of_len()
|
||||
self.assertEqual(list(pl * n), list(ul * n), 'mul by %d' % n)
|
||||
self.assertEqual(type(ul), type(ul * n), 'type of mul by %d result' % n)
|
||||
self.assertEqual(list(n * pl), list(n * ul), 'rmul by %d' % n)
|
||||
self.assertEqual(type(ul), type(n * ul), 'type of rmul by %d result' % n)
|
||||
objid = id(ul)
|
||||
pl *= n
|
||||
ul *= n
|
||||
self.assertEqual(pl[:], ul[:], 'in-place mul by %d' % n)
|
||||
self.assertEqual(objid, id(ul), 'in-place mul by %d id' % n)
|
||||
|
||||
pl, ul = self.lists_of_len()
|
||||
self.assertEqual(pl, ul, 'cmp for equal')
|
||||
self.assertNotEqual(ul, pl + [2], 'cmp for not equal')
|
||||
self.assertGreaterEqual(pl, ul, 'cmp for gte self')
|
||||
self.assertLessEqual(pl, ul, 'cmp for lte self')
|
||||
self.assertGreaterEqual(ul, pl, 'cmp for self gte')
|
||||
self.assertLessEqual(ul, pl, 'cmp for self lte')
|
||||
|
||||
self.assertGreater(pl + [5], ul, 'cmp')
|
||||
self.assertGreaterEqual(pl + [5], ul, 'cmp')
|
||||
self.assertLess(pl, ul + [2], 'cmp')
|
||||
self.assertLessEqual(pl, ul + [2], 'cmp')
|
||||
self.assertGreater(ul + [5], pl, 'cmp')
|
||||
self.assertGreaterEqual(ul + [5], pl, 'cmp')
|
||||
self.assertLess(ul, pl + [2], 'cmp')
|
||||
self.assertLessEqual(ul, pl + [2], 'cmp')
|
||||
|
||||
# Also works with a custom IndexError
|
||||
ul_longer = ul + [2]
|
||||
ul_longer._IndexError = TypeError
|
||||
ul._IndexError = TypeError
|
||||
self.assertNotEqual(ul_longer, pl)
|
||||
self.assertGreater(ul_longer, ul)
|
||||
|
||||
pl[1] = 20
|
||||
self.assertGreater(pl, ul, 'cmp for gt self')
|
||||
self.assertLess(ul, pl, 'cmp for self lt')
|
||||
pl[1] = -20
|
||||
self.assertLess(pl, ul, 'cmp for lt self')
|
||||
self.assertGreater(ul, pl, 'cmp for gt self')
|
||||
|
||||
|
||||
class ListMixinTestSingle(ListMixinTest):
|
||||
listType = UserListB
|
||||
Binary file not shown.
@@ -1 +0,0 @@
|
||||
GEOGCS["GCS_WGS_1984",DATUM["D_WGS_1984",SPHEROID["WGS_1984",6378137,298.257223563]],PRIMEM["Greenwich",0],UNIT["Degree",0.017453292519943295]]
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
@@ -1 +0,0 @@
|
||||
GEOGCS["GCS_WGS_1984",DATUM["D_WGS_1984",SPHEROID["WGS_1984",6378137,298.257223563]],PRIMEM["Greenwich",0],UNIT["Degree",0.017453292519943295]]
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
File diff suppressed because one or more lines are too long
Binary file not shown.
@@ -1 +0,0 @@
|
||||
GEOGCS["GCS_WGS_1984",DATUM["D_WGS_1984",SPHEROID["WGS_1984",6378137,298.257223563]],PRIMEM["Greenwich",0],UNIT["Degree",0.017453292519943295]]
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
@@ -1 +0,0 @@
|
||||
GEOGCS["GCS_WGS_1984",DATUM["D_WGS_1984",SPHEROID["WGS_1984",6378137,298.257223563]],PRIMEM["Greenwich",0],UNIT["Degree",0.017453292519943295]]
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
@@ -1 +0,0 @@
|
||||
GEOGCS["GCS_WGS_1984",DATUM["D_WGS_1984",SPHEROID["WGS_1984",6378137,298.257223563]],PRIMEM["Greenwich",0],UNIT["Degree",0.017453292519943295]]
|
||||
Binary file not shown.
Binary file not shown.
@@ -1,4 +0,0 @@
|
||||
POINT_X,POINT_Y,NUM
|
||||
1.0,2.0,5
|
||||
5.0,23.0,17
|
||||
100.0,523.5,23
|
||||
|
@@ -1,7 +0,0 @@
|
||||
<OGRVRTDataSource>
|
||||
<OGRVRTLayer name="test_vrt">
|
||||
<SrcDataSource relativeToVRT="1">test_vrt.csv</SrcDataSource>
|
||||
<GeometryType>wkbPoint25D</GeometryType>
|
||||
<GeometryField encoding="PointFromColumns" x="POINT_X" y="POINT_Y" z="NUM"/>
|
||||
</OGRVRTLayer>
|
||||
</OGRVRTDataSource>
|
||||
Binary file not shown.
@@ -1,314 +0,0 @@
|
||||
[
|
||||
{
|
||||
"pk": 1,
|
||||
"model": "distapp.southtexascity",
|
||||
"fields": {
|
||||
"name": "Downtown Houston",
|
||||
"point": "SRID=32140;POINT (951640.5473284651525319 4219369.2617166414856911)"
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 2,
|
||||
"model": "distapp.southtexascity",
|
||||
"fields": {
|
||||
"name": "West University Place",
|
||||
"point": "SRID=32140;POINT (943547.9223275661934167 4213623.6534501984715462)"
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 3,
|
||||
"model": "distapp.southtexascity",
|
||||
"fields": {
|
||||
"name": "Southside Place",
|
||||
"point": "SRID=32140;POINT (944704.6433068963233382 4212768.8761719493195415)"
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 4,
|
||||
"model": "distapp.southtexascity",
|
||||
"fields": {
|
||||
"name": "Bellaire",
|
||||
"point": "SRID=32140;POINT (942595.6691285020206124 4212686.7258348800241947)"
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 5,
|
||||
"model": "distapp.southtexascity",
|
||||
"fields": {
|
||||
"name": "Pearland",
|
||||
"point": "SRID=32140;POINT (959674.6165056140162051 4197465.6525986101478338)"
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 6,
|
||||
"model": "distapp.southtexascity",
|
||||
"fields": {
|
||||
"name": "Galveston",
|
||||
"point": "SRID=32140;POINT (1008151.1600717274704948 4170027.4765489147976041)"
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 7,
|
||||
"model": "distapp.southtexascity",
|
||||
"fields": {
|
||||
"name": "Sealy",
|
||||
"point": "SRID=32140;POINT (874859.2868079885374755 4219186.8640952249988914)"
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 8,
|
||||
"model": "distapp.southtexascity",
|
||||
"fields": {
|
||||
"name": "San Antonio",
|
||||
"point": "SRID=32140;POINT (649173.9104827501578256 4176413.2778564509935677)"
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 9,
|
||||
"model": "distapp.southtexascity",
|
||||
"fields": {
|
||||
"name": "Saint Hedwig",
|
||||
"point": "SRID=32140;POINT (677644.6499522707890719 4175467.0674387565813959)"
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 1,
|
||||
"model": "distapp.southtexascityft",
|
||||
"fields": {
|
||||
"name": "Downtown Houston",
|
||||
"point": "SRID=2278;POINT (3122174.0290268082171679 13843047.3191486913710833)"
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 2,
|
||||
"model": "distapp.southtexascityft",
|
||||
"fields": {
|
||||
"name": "West University Place",
|
||||
"point": "SRID=2278;POINT (3095623.4751696921885014 13824196.9360278695821762)"
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 3,
|
||||
"model": "distapp.southtexascityft",
|
||||
"fields": {
|
||||
"name": "Southside Place",
|
||||
"point": "SRID=2278;POINT (3099418.4839160442352295 13821392.5542408134788275)"
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 4,
|
||||
"model": "distapp.southtexascityft",
|
||||
"fields": {
|
||||
"name": "Bellaire",
|
||||
"point": "SRID=2278;POINT (3092499.2911324291490018 13821123.0326766129583120)"
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 5,
|
||||
"model": "distapp.southtexascityft",
|
||||
"fields": {
|
||||
"name": "Pearland",
|
||||
"point": "SRID=2278;POINT (3148532.4709855038672686 13771185.2282339502125978)"
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 6,
|
||||
"model": "distapp.southtexascityft",
|
||||
"fields": {
|
||||
"name": "Galveston",
|
||||
"point": "SRID=2278;POINT (3307575.9310019947588444 13681165.1456442419439554)"
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 7,
|
||||
"model": "distapp.southtexascityft",
|
||||
"fields": {
|
||||
"name": "Sealy",
|
||||
"point": "SRID=2278;POINT (2870267.5101358774118125 13842448.9029524270445108)"
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 8,
|
||||
"model": "distapp.southtexascityft",
|
||||
"fields": {
|
||||
"name": "San Antonio",
|
||||
"point": "SRID=2278;POINT (2129831.4046421577222645 13702115.8954340498894453)"
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 9,
|
||||
"model": "distapp.southtexascityft",
|
||||
"fields": {
|
||||
"name": "Saint Hedwig",
|
||||
"point": "SRID=2278;POINT (2223239.1557184099219739 13699011.5367553308606148)"
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 1,
|
||||
"model": "distapp.australiacity",
|
||||
"fields": {
|
||||
"name": "Wollongong",
|
||||
"point": "SRID=4326;POINT (150.9019999999999868 -34.4245000000000019)"
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 2,
|
||||
"model": "distapp.australiacity",
|
||||
"fields": {
|
||||
"name": "Shellharbour",
|
||||
"point": "SRID=4326;POINT (150.8700000000000045 -34.5788999999999973)"
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 3,
|
||||
"model": "distapp.australiacity",
|
||||
"fields": {
|
||||
"name": "Thirroul",
|
||||
"point": "SRID=4326;POINT (150.9240000000000066 -34.3147000000000020)"
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 4,
|
||||
"model": "distapp.australiacity",
|
||||
"fields": {
|
||||
"name": "Mittagong",
|
||||
"point": "SRID=4326;POINT (150.4490000000000123 -34.4508999999999972)"
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 5,
|
||||
"model": "distapp.australiacity",
|
||||
"fields": {
|
||||
"name": "Batemans Bay",
|
||||
"point": "SRID=4326;POINT (150.1750000000000114 -35.7081999999999979)"
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 6,
|
||||
"model": "distapp.australiacity",
|
||||
"fields": {
|
||||
"name": "Canberra",
|
||||
"point": "SRID=4326;POINT (144.9629999999999939 -37.8143000000000029)"
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 7,
|
||||
"model": "distapp.australiacity",
|
||||
"fields": {
|
||||
"name": "Melbourne",
|
||||
"point": "SRID=4326;POINT (145.9629999999999939 -37.8143000000000029)"
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 8,
|
||||
"model": "distapp.australiacity",
|
||||
"fields": {
|
||||
"name": "Sydney",
|
||||
"point": "SRID=4326;POINT (151.2607099999999889 -33.8870339999999999)"
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 9,
|
||||
"model": "distapp.australiacity",
|
||||
"fields": {
|
||||
"name": "Hobart",
|
||||
"point": "SRID=4326;POINT (147.3300000000000125 -42.8826999999999998)"
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 10,
|
||||
"model": "distapp.australiacity",
|
||||
"fields": {
|
||||
"name": "Adelaide",
|
||||
"point": "SRID=4326;POINT (138.5999999999999943 -34.9258000000000024)"
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 11,
|
||||
"model": "distapp.australiacity",
|
||||
"fields": {
|
||||
"name": "Hillsdale",
|
||||
"point": "SRID=4326;POINT (151.2313409999999863 -33.9526850000000024)"
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 1,
|
||||
"model": "distapp.censuszipcode",
|
||||
"fields": {
|
||||
"name": "77002",
|
||||
"poly": "SRID=4269;POLYGON ((-95.3650149999999996 29.7723270000000007, -95.3624149999999986 29.7723270000000007, -95.3609150000000056 29.7718269999999983, -95.3546149999999955 29.7718269999999983, -95.3515150000000062 29.7725270000000002, -95.3509150000000005 29.7653269999999992, -95.3510150000000039 29.7624360000000010, -95.3501150000000024 29.7603280000000012, -95.3475150000000014 29.7585279999999983, -95.3523150000000044 29.7539279999999984, -95.3564149999999984 29.7563279999999999, -95.3582150000000013 29.7540280000000017, -95.3602149999999966 29.7563279999999999, -95.3634150000000034 29.7571280000000016, -95.3640139999999974 29.7563800000000001, -95.3634150000000034 29.7539279999999984, -95.3600150000000042 29.7518279999999997, -95.3618150000000071 29.7495280000000015, -95.3627149999999943 29.7500280000000004, -95.3675159999999948 29.7441279999999999, -95.3693159999999978 29.7451280000000011, -95.3739159999999941 29.7441279999999999, -95.3801160000000010 29.7380279999999999, -95.3879160000000041 29.7279289999999996, -95.3885159999999956 29.7296289999999992, -95.3879160000000041 29.7321290000000005, -95.3829159999999945 29.7374280000000013, -95.3766159999999985 29.7422280000000008, -95.3726159999999936 29.7472279999999998, -95.3786010000000033 29.7508459999999992, -95.3786159999999938 29.7520279999999993, -95.3786159999999938 29.7544280000000008, -95.3760160000000070 29.7545280000000005, -95.3746160000000032 29.7598279999999988, -95.3736159999999984 29.7611279999999994, -95.3719159999999988 29.7639279999999999, -95.3723159999999979 29.7687269999999984, -95.3658839999999941 29.7679100000000005, -95.3660150000000044 29.7671269999999986, -95.3587150000000037 29.7653269999999992, -95.3586150000000004 29.7663270000000004, -95.3591150000000027 29.7672269999999983, -95.3602149999999966 29.7670269999999988, -95.3627829999999932 29.7682670000000016, -95.3653149999999954 29.7705270000000013, -95.3650149999999996 29.7723270000000007))"
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 2,
|
||||
"model": "distapp.censuszipcode",
|
||||
"fields": {
|
||||
"name": "77005",
|
||||
"poly": "SRID=4269;POLYGON ((-95.4479180000000014 29.7272749999999988, -95.4280169999999970 29.7287290000000013, -95.4211169999999953 29.7290290000000006, -95.4186169999999976 29.7276290000000003, -95.4185169999999943 29.7264289999999995, -95.4021170000000041 29.7266289999999991, -95.4021170000000041 29.7257290000000012, -95.3953159999999940 29.7257290000000012, -95.3919159999999948 29.7262290000000000, -95.3897160000000071 29.7258290000000009, -95.3965170000000029 29.7154290000000003, -95.3975169999999935 29.7159289999999991, -95.4009170000000069 29.7114289999999990, -95.4114170000000001 29.7150290000000012, -95.4184170000000051 29.7147289999999984, -95.4183170000000018 29.7062300000000015, -95.4408179999999930 29.7059299999999986, -95.4450180000000046 29.7068300000000001, -95.4466180000000008 29.7076300000000018, -95.4474179999999990 29.7100299999999997, -95.4479180000000014 29.7272749999999988))"
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 3,
|
||||
"model": "distapp.censuszipcode",
|
||||
"fields": {
|
||||
"name": "77025",
|
||||
"poly": "SRID=4269;POLYGON ((-95.4183170000000018 29.7062300000000015, -95.4147169999999960 29.7061290000000007, -95.4146170000000069 29.7053300000000000, -95.4182169999999985 29.7053300000000000, -95.4198169999999948 29.6953299999999984, -95.4194839999999971 29.6941960000000016, -95.4171659999999946 29.6909010000000002, -95.4145170000000036 29.6943300000000008, -95.4133170000000064 29.6926300000000012, -95.4126169999999973 29.6897300000000008, -95.4128170000000040 29.6875299999999989, -95.4140869999999950 29.6850549999999984, -95.4191650000000067 29.6854280000000017, -95.4216169999999977 29.6851300000000009, -95.4257170000000059 29.6798299999999990, -95.4250169999999969 29.6792300000000004, -95.4245169999999945 29.6776300000000006, -95.4274180000000030 29.6776300000000006, -95.4380179999999996 29.6646310000000000, -95.4367129999999975 29.6644110000000012, -95.4401179999999982 29.6622309999999985, -95.4392179999999968 29.6610310000000013, -95.4377180000000038 29.6601309999999998, -95.4357179999999943 29.6597310000000007, -95.4318180000000069 29.6603309999999993, -95.4414179999999988 29.6566310000000009, -95.4413179999999954 29.6563310000000016, -95.4418179999999978 29.6561309999999985, -95.4417179999999945 29.6590309999999988, -95.4411180000000030 29.6610310000000013, -95.4467180000000042 29.6564310000000013, -95.4465179999999975 29.6734310000000008, -95.4469179999999966 29.6901299999999999, -95.4474179999999990 29.7100299999999997, -95.4466180000000008 29.7076300000000018, -95.4450180000000046 29.7068300000000001, -95.4408179999999930 29.7059299999999986, -95.4183170000000018 29.7062300000000015))"
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 4,
|
||||
"model": "distapp.censuszipcode",
|
||||
"fields": {
|
||||
"name": "77401",
|
||||
"poly": "SRID=4269;POLYGON ((-95.4479180000000014 29.7272749999999988, -95.4474179999999990 29.7100299999999997, -95.4469179999999966 29.6901299999999999, -95.4543180000000007 29.6889299999999992, -95.4758190000000013 29.6890299999999989, -95.4758190000000013 29.6911300000000011, -95.4844190000000026 29.6910300000000014, -95.4845190000000059 29.6990300000000005, -95.4804189999999977 29.7013299999999987, -95.4804189999999977 29.6983299999999986, -95.4741190000000017 29.6983299999999986, -95.4741190000000017 29.7045299999999983, -95.4727189999999979 29.7128300000000003, -95.4680189999999982 29.7129300000000001, -95.4682190000000048 29.7202289999999998, -95.4640179999999958 29.7202289999999998, -95.4641179999999991 29.7245290000000004, -95.4630180000000053 29.7259290000000007, -95.4598179999999985 29.7261290000000002, -95.4599180000000018 29.7203289999999996, -95.4514180000000039 29.7204289999999993, -95.4517749999999978 29.7263030000000015, -95.4513180000000006 29.7270290000000017, -95.4479180000000014 29.7272749999999988))"
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 1,
|
||||
"model": "distapp.southtexaszipcode",
|
||||
"fields": {
|
||||
"name": "77002",
|
||||
"poly": "SRID=32140;POLYGON ((951429.5409192872466519 4220355.4988148519769311, 951680.8273045794339851 4220363.3144243787974119, 951827.5242763287387788 4220312.4344643373042345, 952436.4125371500849724 4220331.4033580468967557, 952733.6038219904294237 4220418.2972162021324039, 952816.4884229446761310 4219622.4721539746969938, 952816.8189755391795188 4219301.8983748322352767, 952911.1013538520783186 4219071.0846072295680642, 953168.6460092773195356 4218879.5251544509083033, 952720.5711025173077360 4218355.4412181628867984, 952315.9552874444052577 4218608.9603398498147726, 952149.8976783070247620 4218348.7396276174113154, 951948.6335086676990613 4218597.5187743240967393, 951636.5529057731619105 4218676.5191153362393379, 951581.2288653708528727 4218591.8528460673987865, 951647.5797480825567618 4218322.0148884318768978, 951983.4872268696781248 4218099.5997478468343616, 951817.4139249715954065 4217839.3842275496572256, 951728.6875000044237822 4217892.0683275610208511, 951284.8837139783427119 4217224.0225605471059680, 951107.4276299364864826 4217329.3996630022302270, 950666.1605060384608805 4217204.8158583818003535, 950087.6947283914778382 4216510.4676794996485114, 949368.1435158180538565 4215368.3503736928105354, 949304.3111934799235314 4215554.8883790764957666, 949353.7683630869723856 4215833.6369291869923472, 949819.0428102404111996 4216435.6196845080703497, 950411.6597438841126859 4216986.2362841432914138, 950781.1835370573680848 4217552.1403498277068138, 950190.1823301381664351 4217935.0160658890381455, 950184.6762747208122164 4218065.9165289513766766, 950176.4407065160339698 4218331.7956013763323426, 950427.4286870528012514 4218350.6616439744830132, 950544.5537801468744874 4218942.0070019531995058, 950636.7473976470064372 4219089.0227092057466507, 950791.4425049067940563 4219404.3132666023448110, 950736.2833876821678132 4219934.7619700236245990, 951360.7634590273955837 4219863.5588980689644814, 951350.7981466529890895 4219776.4222313342615962, 952062.5793334231711924 4219598.9663440436124802, 952068.7943994677625597 4219710.0501319468021393, 952017.3623401129152626 4219808.2495522042736411, 951911.7334559946320951 4219782.7825336037203670, 951659.2534216577187181 4219912.4288446288555861, 951406.7457121167099103 4220155.1877524554729462, 951429.5409192872466519 4220355.4988148519769311))"
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 2,
|
||||
"model": "distapp.southtexaszipcode",
|
||||
"fields": {
|
||||
"name": "77005",
|
||||
"poly": "SRID=32140;POLYGON ((943568.6284788220655173 4215118.1416417406871915, 945487.9980521594407037 4215337.8481928687542677, 946154.1517634749179706 4215391.4863748690113425, 946400.6304061285918579 4215243.7918130923062563, 946414.3720398070290685 4215111.1480321725830436, 947999.4599494948051870 4215181.9933486394584179, 948002.5282293657073751 4215082.2888173414394259, 948660.1417131680063903 4215102.5451732110232115, 948987.1902349996380508 4215168.0774542130529881, 949201.2831489123636857 4215130.3313774159178138, 948579.1820738224778324 4213957.9057207889854908, 948480.7719409475103021 4214010.3167602103203535, 948167.3284030471695587 4213501.6696778312325478, 947139.6595406322740018 4213869.2741038342937827, 946463.7483147600432858 4213815.2817387804389000, 946502.2630172523204237 4212874.0348161971196532, 944327.1378451543860137 4212774.3432321334257722, 943917.9093748427694663 4212861.6900106100365520, 943760.4753683793824166 4212945.6127811912447214, 943675.0267053353600204 4213209.1422286527231336, 943568.6284788220655173 4215118.1416417406871915))"
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 3,
|
||||
"model": "distapp.southtexaszipcode",
|
||||
"fields": {
|
||||
"name": "77025",
|
||||
"poly": "SRID=32140;POLYGON ((946502.2630172523204237 4212874.0348161971196532, 946850.7713855113834143 4212873.5172070376574993, 946863.1571223458740860 4212785.2985141929239035, 946514.9888159723486751 4212774.6266902117058635, 946394.1713412774261087 4211662.0614421153441072, 946430.2274363302858546 4211537.4205564847216010, 946665.6199423221405596 4211179.2615583632141352, 946910.2001898437738419 4211566.9887375179678202, 947032.0462735339533538 4211382.2191729480400681, 947109.6117705166107044 4211063.0284381639212370, 947097.7440171607304364 4210818.7144018746912479, 946983.3062754627317190 4210540.7604114022105932, 946490.8323894963832572 4210567.0268272040411830, 946254.6550409919582307 4210526.7516811080276966, 945876.0008902740664780 4209927.4740557167679071, 945945.7498299231519923 4209863.0751969292759895, 945999.5397084732539952 4209687.3030018107965589, 945718.8972609748598188 4209678.7238750727847219, 944737.3260139031335711 4208207.3771017007529736, 944864.3308290732093155 4208186.8525157077237964, 944542.2412279490381479 4207935.3116904916241765, 944633.3693750606616959 4207805.0250262534245849, 944781.5411592419259250 4207709.7424235185608268, 944976.4055775101296604 4207671.3274960424751043, 945351.7294723913073540 4207749.3068800456821918, 944435.3426235395018011 4207311.1031644716858864, 944446.0302430286537856 4207278.1630970388650894, 944398.3243151376955211 4207254.5342014739289880, 944398.2226623257156461 4207576.0964536992833018, 944449.5330111491493881 4207799.4275652254000306, 943923.1866919576423243 4207273.3492023386061192, 943885.2983187574427575 4209157.2369952416047454, 943790.3796654250472784 4211006.0231411391869187, 943675.0267053353600204 4213209.1422286527231336, 943760.4753683793824166 4212945.6127811912447214, 943917.9093748427694663 4212861.6900106100365520, 944327.1378451543860137 4212774.3432321334257722, 946502.2630172523204237 4212874.0348161971196532))"
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 4,
|
||||
"model": "distapp.southtexaszipcode",
|
||||
"fields": {
|
||||
"name": "77401",
|
||||
"poly": "SRID=32140;POLYGON ((943568.6284788220655173 4215118.1416417406871915, 943675.0267053353600204 4213209.1422286527231336, 943790.3796654250472784 4211006.0231411391869187, 943078.6190994082717225 4210851.3527729213237762, 940998.4896008004434407 4210799.5486384732648730, 940991.4769605984911323 4211032.1947893090546131, 940159.9452393862884492 4210996.0721307108178735, 940123.6234478773549199 4211882.0554536599665880, 940512.5092238665092736 4212148.7901582065969706, 940522.5142344047781080 4211816.4372764797881246, 941131.8601800086908042 4211834.7971962466835976, 941111.1461491615045816 4212521.6589920166879892, 941218.8068687882041559 4213445.2531420132145286, 941672.9982470837421715 4213470.0535286460071802, 941629.2300919098779559 4214278.0848444234579802, 942035.4691281586419791 4214290.3638116680085659, 942011.3920782012864947 4214766.4446664610877633, 942113.0660258040297776 4214924.7603673832491040, 942421.8192426580935717 4214956.2823535148054361, 942431.6055385319050401 4214313.4400705620646477, 943253.2209875346161425 4214349.4362764349207282, 943198.9497700630454347 4214999.1347201215103269, 943240.6978847808204591 4215080.9052637927234173, 943568.6284788220655173 4215118.1416417406871915))"
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 1,
|
||||
"model": "distapp.interstate",
|
||||
"fields": {
|
||||
"path": "SRID=4326;LINESTRING (-104.4780170766107972 36.6669879187069370, -104.4468522338494978 36.7992540939338610, -104.4621269262599981 36.9372149776075034, -104.5126119783767962 37.0816326882088703, -104.5247764602161027 37.2930049989204804, -104.7084397427667994 37.4915025992539768, -104.8126599016281943 37.6951428562186308, -104.8452887035466006 37.8761339565947921, -104.7160169341002955 38.0595176333779932, -104.6165437927668052 38.3043204585510608, -104.6437227858174026 38.5397998656473675, -104.7596170387259065 38.7322907594295032, -104.8380078676821938 38.8999846060434109, -104.8501253693505930 39.0998018921335770, -104.8791648316464062 39.2436877645750286, -104.8635041274215070 39.3785278162751027, -104.8894471170052043 39.5929228239604996, -104.9721242843343987 39.6952848241968468, -105.0112104500356054 39.7273080432393968, -105.0010368577104032 39.7667760781157114, -104.9818356189999946 39.8146650412196692, -104.9858891550477011 39.8880691125083189, -104.9873548059578070 39.9811723457101635, -104.9766220487419019 40.0979642345069180, -104.9818565932953049 40.3605653066288426, -104.9912746373996981 40.7490448444765576)",
|
||||
"name": "I-25"
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 1,
|
||||
"model": "distapp.southtexasinterstate",
|
||||
"fields": {
|
||||
"path": "SRID=32140;LINESTRING (924952.5000000000000000 4220931.5999999996274710, 925065.3000000000465661 4220931.5999999996274710, 929568.4000000000232831 4221057.7999999998137355)",
|
||||
"name": "I-10"
|
||||
}
|
||||
}
|
||||
]
|
||||
@@ -1,52 +0,0 @@
|
||||
from django.contrib.gis.db import models
|
||||
from django.contrib.gis.tests.utils import gisfield_may_be_null
|
||||
from django.utils.encoding import python_2_unicode_compatible
|
||||
|
||||
|
||||
@python_2_unicode_compatible
|
||||
class NamedModel(models.Model):
|
||||
name = models.CharField(max_length=30)
|
||||
|
||||
objects = models.GeoManager()
|
||||
|
||||
class Meta:
|
||||
abstract = True
|
||||
app_label = 'distapp'
|
||||
|
||||
def __str__(self):
|
||||
return self.name
|
||||
|
||||
|
||||
class SouthTexasCity(NamedModel):
|
||||
"City model on projected coordinate system for South Texas."
|
||||
point = models.PointField(srid=32140)
|
||||
|
||||
|
||||
class SouthTexasCityFt(NamedModel):
|
||||
"Same City model as above, but U.S. survey feet are the units."
|
||||
point = models.PointField(srid=2278)
|
||||
|
||||
|
||||
class AustraliaCity(NamedModel):
|
||||
"City model for Australia, using WGS84."
|
||||
point = models.PointField()
|
||||
|
||||
|
||||
class CensusZipcode(NamedModel):
|
||||
"Model for a few South Texas ZIP codes (in original Census NAD83)."
|
||||
poly = models.PolygonField(srid=4269)
|
||||
|
||||
|
||||
class SouthTexasZipcode(NamedModel):
|
||||
"Model for a few South Texas ZIP codes."
|
||||
poly = models.PolygonField(srid=32140, null=gisfield_may_be_null)
|
||||
|
||||
|
||||
class Interstate(NamedModel):
|
||||
"Geodetic model for U.S. Interstates."
|
||||
path = models.LineStringField()
|
||||
|
||||
|
||||
class SouthTexasInterstate(NamedModel):
|
||||
"Projected model for South Texas Interstates."
|
||||
path = models.LineStringField(srid=32140)
|
||||
@@ -1,386 +0,0 @@
|
||||
from __future__ import unicode_literals
|
||||
|
||||
from django.contrib.gis.geos import HAS_GEOS
|
||||
from django.contrib.gis.measure import D # alias for Distance
|
||||
from django.contrib.gis.tests.utils import (
|
||||
no_oracle, oracle, postgis, spatialite,
|
||||
)
|
||||
from django.db import connection
|
||||
from django.db.models import Q
|
||||
from django.test import TestCase, skipUnlessDBFeature
|
||||
|
||||
if HAS_GEOS:
|
||||
from django.contrib.gis.geos import GEOSGeometry, LineString
|
||||
|
||||
from .models import (AustraliaCity, Interstate, SouthTexasInterstate,
|
||||
SouthTexasCity, SouthTexasCityFt, CensusZipcode, SouthTexasZipcode)
|
||||
|
||||
|
||||
@skipUnlessDBFeature("gis_enabled")
|
||||
class DistanceTest(TestCase):
|
||||
fixtures = ['initial']
|
||||
|
||||
if HAS_GEOS:
|
||||
# A point we are testing distances with -- using a WGS84
|
||||
# coordinate that'll be implicitly transformed to that to
|
||||
# the coordinate system of the field, EPSG:32140 (Texas South Central
|
||||
# w/units in meters)
|
||||
stx_pnt = GEOSGeometry('POINT (-95.370401017314293 29.704867409475465)', 4326)
|
||||
# Another one for Australia
|
||||
au_pnt = GEOSGeometry('POINT (150.791 -34.4919)', 4326)
|
||||
|
||||
def get_names(self, qs):
|
||||
cities = [c.name for c in qs]
|
||||
cities.sort()
|
||||
return cities
|
||||
|
||||
def test_init(self):
|
||||
"""
|
||||
Test initialization of distance models.
|
||||
"""
|
||||
self.assertEqual(9, SouthTexasCity.objects.count())
|
||||
self.assertEqual(9, SouthTexasCityFt.objects.count())
|
||||
self.assertEqual(11, AustraliaCity.objects.count())
|
||||
self.assertEqual(4, SouthTexasZipcode.objects.count())
|
||||
self.assertEqual(4, CensusZipcode.objects.count())
|
||||
self.assertEqual(1, Interstate.objects.count())
|
||||
self.assertEqual(1, SouthTexasInterstate.objects.count())
|
||||
|
||||
@skipUnlessDBFeature("supports_dwithin_lookup")
|
||||
def test_dwithin(self):
|
||||
"""
|
||||
Test the `dwithin` lookup type.
|
||||
"""
|
||||
# Distances -- all should be equal (except for the
|
||||
# degree/meter pair in au_cities, that's somewhat
|
||||
# approximate).
|
||||
tx_dists = [(7000, 22965.83), D(km=7), D(mi=4.349)]
|
||||
au_dists = [(0.5, 32000), D(km=32), D(mi=19.884)]
|
||||
|
||||
# Expected cities for Australia and Texas.
|
||||
tx_cities = ['Downtown Houston', 'Southside Place']
|
||||
au_cities = ['Mittagong', 'Shellharbour', 'Thirroul', 'Wollongong']
|
||||
|
||||
# Performing distance queries on two projected coordinate systems one
|
||||
# with units in meters and the other in units of U.S. survey feet.
|
||||
for dist in tx_dists:
|
||||
if isinstance(dist, tuple):
|
||||
dist1, dist2 = dist
|
||||
else:
|
||||
dist1 = dist2 = dist
|
||||
qs1 = SouthTexasCity.objects.filter(point__dwithin=(self.stx_pnt, dist1))
|
||||
qs2 = SouthTexasCityFt.objects.filter(point__dwithin=(self.stx_pnt, dist2))
|
||||
for qs in qs1, qs2:
|
||||
self.assertEqual(tx_cities, self.get_names(qs))
|
||||
|
||||
# Now performing the `dwithin` queries on a geodetic coordinate system.
|
||||
for dist in au_dists:
|
||||
if isinstance(dist, D) and not oracle:
|
||||
type_error = True
|
||||
else:
|
||||
type_error = False
|
||||
|
||||
if isinstance(dist, tuple):
|
||||
if oracle:
|
||||
dist = dist[1]
|
||||
else:
|
||||
dist = dist[0]
|
||||
|
||||
# Creating the query set.
|
||||
qs = AustraliaCity.objects.order_by('name')
|
||||
if type_error:
|
||||
# A ValueError should be raised on PostGIS when trying to pass
|
||||
# Distance objects into a DWithin query using a geodetic field.
|
||||
self.assertRaises(ValueError, AustraliaCity.objects.filter(point__dwithin=(self.au_pnt, dist)).count)
|
||||
else:
|
||||
self.assertListEqual(au_cities, self.get_names(qs.filter(point__dwithin=(self.au_pnt, dist))))
|
||||
|
||||
@skipUnlessDBFeature("has_distance_method")
|
||||
def test_distance_projected(self):
|
||||
"""
|
||||
Test the `distance` GeoQuerySet method on projected coordinate systems.
|
||||
"""
|
||||
# The point for La Grange, TX
|
||||
lagrange = GEOSGeometry('POINT(-96.876369 29.905320)', 4326)
|
||||
# Reference distances in feet and in meters. Got these values from
|
||||
# using the provided raw SQL statements.
|
||||
# SELECT ST_Distance(point, ST_Transform(ST_GeomFromText('POINT(-96.876369 29.905320)', 4326), 32140))
|
||||
# FROM distapp_southtexascity;
|
||||
m_distances = [147075.069813, 139630.198056, 140888.552826,
|
||||
138809.684197, 158309.246259, 212183.594374,
|
||||
70870.188967, 165337.758878, 139196.085105]
|
||||
# SELECT ST_Distance(point, ST_Transform(ST_GeomFromText('POINT(-96.876369 29.905320)', 4326), 2278))
|
||||
# FROM distapp_southtexascityft;
|
||||
# Oracle 11 thinks this is not a projected coordinate system, so it's
|
||||
# not tested.
|
||||
ft_distances = [482528.79154625, 458103.408123001, 462231.860397575,
|
||||
455411.438904354, 519386.252102563, 696139.009211594,
|
||||
232513.278304279, 542445.630586414, 456679.155883207]
|
||||
|
||||
# Testing using different variations of parameters and using models
|
||||
# with different projected coordinate systems.
|
||||
dist1 = SouthTexasCity.objects.distance(lagrange, field_name='point').order_by('id')
|
||||
dist2 = SouthTexasCity.objects.distance(lagrange).order_by('id') # Using GEOSGeometry parameter
|
||||
if spatialite or oracle:
|
||||
dist_qs = [dist1, dist2]
|
||||
else:
|
||||
dist3 = SouthTexasCityFt.objects.distance(lagrange.ewkt).order_by('id') # Using EWKT string parameter.
|
||||
dist4 = SouthTexasCityFt.objects.distance(lagrange).order_by('id')
|
||||
dist_qs = [dist1, dist2, dist3, dist4]
|
||||
|
||||
# Original query done on PostGIS, have to adjust AlmostEqual tolerance
|
||||
# for Oracle.
|
||||
tol = 2 if oracle else 5
|
||||
|
||||
# Ensuring expected distances are returned for each distance queryset.
|
||||
for qs in dist_qs:
|
||||
for i, c in enumerate(qs):
|
||||
self.assertAlmostEqual(m_distances[i], c.distance.m, tol)
|
||||
self.assertAlmostEqual(ft_distances[i], c.distance.survey_ft, tol)
|
||||
|
||||
@skipUnlessDBFeature("has_distance_method", "supports_distance_geodetic")
|
||||
def test_distance_geodetic(self):
|
||||
"""
|
||||
Test the `distance` GeoQuerySet method on geodetic coordinate systems.
|
||||
"""
|
||||
tol = 2 if oracle else 5
|
||||
|
||||
# Testing geodetic distance calculation with a non-point geometry
|
||||
# (a LineString of Wollongong and Shellharbour coords).
|
||||
ls = LineString(((150.902, -34.4245), (150.87, -34.5789)))
|
||||
|
||||
# Reference query:
|
||||
# SELECT ST_distance_sphere(point, ST_GeomFromText('LINESTRING(150.9020 -34.4245,150.8700 -34.5789)', 4326))
|
||||
# FROM distapp_australiacity ORDER BY name;
|
||||
distances = [1120954.92533513, 140575.720018241, 640396.662906304,
|
||||
60580.9693849269, 972807.955955075, 568451.8357838,
|
||||
40435.4335201384, 0, 68272.3896586844, 12375.0643697706, 0]
|
||||
qs = AustraliaCity.objects.distance(ls).order_by('name')
|
||||
for city, distance in zip(qs, distances):
|
||||
# Testing equivalence to within a meter.
|
||||
self.assertAlmostEqual(distance, city.distance.m, 0)
|
||||
|
||||
# Got the reference distances using the raw SQL statements:
|
||||
# SELECT ST_distance_spheroid(point, ST_GeomFromText('POINT(151.231341 -33.952685)', 4326),
|
||||
# 'SPHEROID["WGS 84",6378137.0,298.257223563]') FROM distapp_australiacity WHERE (NOT (id = 11));
|
||||
# SELECT ST_distance_sphere(point, ST_GeomFromText('POINT(151.231341 -33.952685)', 4326))
|
||||
# FROM distapp_australiacity WHERE (NOT (id = 11)); st_distance_sphere
|
||||
if connection.ops.postgis and connection.ops.proj_version_tuple() >= (4, 7, 0):
|
||||
# PROJ.4 versions 4.7+ have updated datums, and thus different
|
||||
# distance values.
|
||||
spheroid_distances = [60504.0628957201, 77023.9489850262, 49154.8867574404,
|
||||
90847.4358768573, 217402.811919332, 709599.234564757,
|
||||
640011.483550888, 7772.00667991925, 1047861.78619339,
|
||||
1165126.55236034]
|
||||
sphere_distances = [60580.9693849267, 77144.0435286473, 49199.4415344719,
|
||||
90804.7533823494, 217713.384600405, 709134.127242793,
|
||||
639828.157159169, 7786.82949717788, 1049204.06569028,
|
||||
1162623.7238134]
|
||||
|
||||
else:
|
||||
spheroid_distances = [60504.0628825298, 77023.948962654, 49154.8867507115,
|
||||
90847.435881812, 217402.811862568, 709599.234619957,
|
||||
640011.483583758, 7772.00667666425, 1047861.7859506,
|
||||
1165126.55237647]
|
||||
sphere_distances = [60580.7612632291, 77143.7785056615, 49199.2725132184,
|
||||
90804.4414289463, 217712.63666124, 709131.691061906,
|
||||
639825.959074112, 7786.80274606706, 1049200.46122281,
|
||||
1162619.7297006]
|
||||
|
||||
# Testing with spheroid distances first.
|
||||
hillsdale = AustraliaCity.objects.get(name='Hillsdale')
|
||||
qs = AustraliaCity.objects.exclude(id=hillsdale.id).distance(hillsdale.point, spheroid=True).order_by('id')
|
||||
for i, c in enumerate(qs):
|
||||
self.assertAlmostEqual(spheroid_distances[i], c.distance.m, tol)
|
||||
if postgis:
|
||||
# PostGIS uses sphere-only distances by default, testing these as well.
|
||||
qs = AustraliaCity.objects.exclude(id=hillsdale.id).distance(hillsdale.point).order_by('id')
|
||||
for i, c in enumerate(qs):
|
||||
self.assertAlmostEqual(sphere_distances[i], c.distance.m, tol)
|
||||
|
||||
@no_oracle # Oracle already handles geographic distance calculation.
|
||||
@skipUnlessDBFeature("has_distance_method")
|
||||
def test_distance_transform(self):
|
||||
"""
|
||||
Test the `distance` GeoQuerySet method used with `transform` on a geographic field.
|
||||
"""
|
||||
# We'll be using a Polygon (created by buffering the centroid
|
||||
# of 77005 to 100m) -- which aren't allowed in geographic distance
|
||||
# queries normally, however our field has been transformed to
|
||||
# a non-geographic system.
|
||||
z = SouthTexasZipcode.objects.get(name='77005')
|
||||
|
||||
# Reference query:
|
||||
# SELECT ST_Distance(ST_Transform("distapp_censuszipcode"."poly", 32140),
|
||||
# ST_GeomFromText('<buffer_wkt>', 32140))
|
||||
# FROM "distapp_censuszipcode";
|
||||
dists_m = [3553.30384972258, 1243.18391525602, 2186.15439472242]
|
||||
|
||||
# Having our buffer in the SRID of the transformation and of the field
|
||||
# -- should get the same results. The first buffer has no need for
|
||||
# transformation SQL because it is the same SRID as what was given
|
||||
# to `transform()`. The second buffer will need to be transformed,
|
||||
# however.
|
||||
buf1 = z.poly.centroid.buffer(100)
|
||||
buf2 = buf1.transform(4269, clone=True)
|
||||
ref_zips = ['77002', '77025', '77401']
|
||||
|
||||
for buf in [buf1, buf2]:
|
||||
qs = CensusZipcode.objects.exclude(name='77005').transform(32140).distance(buf).order_by('name')
|
||||
self.assertListEqual(ref_zips, self.get_names(qs))
|
||||
for i, z in enumerate(qs):
|
||||
self.assertAlmostEqual(z.distance.m, dists_m[i], 5)
|
||||
|
||||
@skipUnlessDBFeature("supports_distances_lookups")
|
||||
def test_distance_lookups(self):
|
||||
"""
|
||||
Test the `distance_lt`, `distance_gt`, `distance_lte`, and `distance_gte` lookup types.
|
||||
"""
|
||||
# Retrieving the cities within a 20km 'donut' w/a 7km radius 'hole'
|
||||
# (thus, Houston and Southside place will be excluded as tested in
|
||||
# the `test02_dwithin` above).
|
||||
qs1 = SouthTexasCity.objects.filter(point__distance_gte=(self.stx_pnt, D(km=7))).filter(
|
||||
point__distance_lte=(self.stx_pnt, D(km=20)),
|
||||
)
|
||||
|
||||
# Can't determine the units on SpatiaLite from PROJ.4 string, and
|
||||
# Oracle 11 incorrectly thinks it is not projected.
|
||||
if spatialite or oracle:
|
||||
dist_qs = (qs1,)
|
||||
else:
|
||||
qs2 = SouthTexasCityFt.objects.filter(point__distance_gte=(self.stx_pnt, D(km=7))).filter(
|
||||
point__distance_lte=(self.stx_pnt, D(km=20)),
|
||||
)
|
||||
dist_qs = (qs1, qs2)
|
||||
|
||||
for qs in dist_qs:
|
||||
cities = self.get_names(qs)
|
||||
self.assertEqual(cities, ['Bellaire', 'Pearland', 'West University Place'])
|
||||
|
||||
# Doing a distance query using Polygons instead of a Point.
|
||||
z = SouthTexasZipcode.objects.get(name='77005')
|
||||
qs = SouthTexasZipcode.objects.exclude(name='77005').filter(poly__distance_lte=(z.poly, D(m=275)))
|
||||
self.assertEqual(['77025', '77401'], self.get_names(qs))
|
||||
# If we add a little more distance 77002 should be included.
|
||||
qs = SouthTexasZipcode.objects.exclude(name='77005').filter(poly__distance_lte=(z.poly, D(m=300)))
|
||||
self.assertEqual(['77002', '77025', '77401'], self.get_names(qs))
|
||||
|
||||
@skipUnlessDBFeature("supports_distances_lookups", "supports_distance_geodetic")
|
||||
def test_geodetic_distance_lookups(self):
|
||||
"""
|
||||
Test distance lookups on geodetic coordinate systems.
|
||||
"""
|
||||
# Line is from Canberra to Sydney. Query is for all other cities within
|
||||
# a 100km of that line (which should exclude only Hobart & Adelaide).
|
||||
line = GEOSGeometry('LINESTRING(144.9630 -37.8143,151.2607 -33.8870)', 4326)
|
||||
dist_qs = AustraliaCity.objects.filter(point__distance_lte=(line, D(km=100)))
|
||||
|
||||
self.assertEqual(9, dist_qs.count())
|
||||
self.assertEqual(['Batemans Bay', 'Canberra', 'Hillsdale',
|
||||
'Melbourne', 'Mittagong', 'Shellharbour',
|
||||
'Sydney', 'Thirroul', 'Wollongong'],
|
||||
self.get_names(dist_qs))
|
||||
|
||||
# Too many params (4 in this case) should raise a ValueError.
|
||||
queryset = AustraliaCity.objects.filter(point__distance_lte=('POINT(5 23)', D(km=100), 'spheroid', '4'))
|
||||
self.assertRaises(ValueError, len, queryset)
|
||||
|
||||
# Not enough params should raise a ValueError.
|
||||
self.assertRaises(ValueError, len,
|
||||
AustraliaCity.objects.filter(point__distance_lte=('POINT(5 23)',)))
|
||||
|
||||
# Getting all cities w/in 550 miles of Hobart.
|
||||
hobart = AustraliaCity.objects.get(name='Hobart')
|
||||
qs = AustraliaCity.objects.exclude(name='Hobart').filter(point__distance_lte=(hobart.point, D(mi=550)))
|
||||
cities = self.get_names(qs)
|
||||
self.assertEqual(cities, ['Batemans Bay', 'Canberra', 'Melbourne'])
|
||||
|
||||
# Cities that are either really close or really far from Wollongong --
|
||||
# and using different units of distance.
|
||||
wollongong = AustraliaCity.objects.get(name='Wollongong')
|
||||
d1, d2 = D(yd=19500), D(nm=400) # Yards (~17km) & Nautical miles.
|
||||
|
||||
# Normal geodetic distance lookup (uses `distance_sphere` on PostGIS.
|
||||
gq1 = Q(point__distance_lte=(wollongong.point, d1))
|
||||
gq2 = Q(point__distance_gte=(wollongong.point, d2))
|
||||
qs1 = AustraliaCity.objects.exclude(name='Wollongong').filter(gq1 | gq2)
|
||||
|
||||
# Geodetic distance lookup but telling GeoDjango to use `distance_spheroid`
|
||||
# instead (we should get the same results b/c accuracy variance won't matter
|
||||
# in this test case).
|
||||
querysets = [qs1]
|
||||
if connection.features.has_distance_spheroid_method:
|
||||
gq3 = Q(point__distance_lte=(wollongong.point, d1, 'spheroid'))
|
||||
gq4 = Q(point__distance_gte=(wollongong.point, d2, 'spheroid'))
|
||||
qs2 = AustraliaCity.objects.exclude(name='Wollongong').filter(gq3 | gq4)
|
||||
querysets.append(qs2)
|
||||
|
||||
for qs in querysets:
|
||||
cities = self.get_names(qs)
|
||||
self.assertEqual(cities, ['Adelaide', 'Hobart', 'Shellharbour', 'Thirroul'])
|
||||
|
||||
@skipUnlessDBFeature("has_area_method")
|
||||
def test_area(self):
|
||||
"""
|
||||
Test the `area` GeoQuerySet method.
|
||||
"""
|
||||
# Reference queries:
|
||||
# SELECT ST_Area(poly) FROM distapp_southtexaszipcode;
|
||||
area_sq_m = [5437908.90234375, 10183031.4389648, 11254471.0073242, 9881708.91772461]
|
||||
# Tolerance has to be lower for Oracle
|
||||
tol = 2
|
||||
for i, z in enumerate(SouthTexasZipcode.objects.order_by('name').area()):
|
||||
self.assertAlmostEqual(area_sq_m[i], z.area.sq_m, tol)
|
||||
|
||||
@skipUnlessDBFeature("has_length_method")
|
||||
def test_length(self):
|
||||
"""
|
||||
Test the `length` GeoQuerySet method.
|
||||
"""
|
||||
# Reference query (should use `length_spheroid`).
|
||||
# SELECT ST_length_spheroid(ST_GeomFromText('<wkt>', 4326) 'SPHEROID["WGS 84",6378137,298.257223563,
|
||||
# AUTHORITY["EPSG","7030"]]');
|
||||
len_m1 = 473504.769553813
|
||||
len_m2 = 4617.668
|
||||
|
||||
if connection.features.supports_distance_geodetic:
|
||||
qs = Interstate.objects.length()
|
||||
tol = 2 if oracle else 3
|
||||
self.assertAlmostEqual(len_m1, qs[0].length.m, tol)
|
||||
else:
|
||||
# Does not support geodetic coordinate systems.
|
||||
self.assertRaises(ValueError, Interstate.objects.length)
|
||||
|
||||
# Now doing length on a projected coordinate system.
|
||||
i10 = SouthTexasInterstate.objects.length().get(name='I-10')
|
||||
self.assertAlmostEqual(len_m2, i10.length.m, 2)
|
||||
|
||||
@skipUnlessDBFeature("has_perimeter_method")
|
||||
def test_perimeter(self):
|
||||
"""
|
||||
Test the `perimeter` GeoQuerySet method.
|
||||
"""
|
||||
# Reference query:
|
||||
# SELECT ST_Perimeter(distapp_southtexaszipcode.poly) FROM distapp_southtexaszipcode;
|
||||
perim_m = [18404.3550889361, 15627.2108551001, 20632.5588368978, 17094.5996143697]
|
||||
tol = 2 if oracle else 7
|
||||
for i, z in enumerate(SouthTexasZipcode.objects.order_by('name').perimeter()):
|
||||
self.assertAlmostEqual(perim_m[i], z.perimeter.m, tol)
|
||||
|
||||
# Running on points; should return 0.
|
||||
for i, c in enumerate(SouthTexasCity.objects.perimeter(model_att='perim')):
|
||||
self.assertEqual(0, c.perim.m)
|
||||
|
||||
@skipUnlessDBFeature("has_area_method", "has_distance_method")
|
||||
def test_measurement_null_fields(self):
|
||||
"""
|
||||
Test the measurement GeoQuerySet methods on fields with NULL values.
|
||||
"""
|
||||
# Creating SouthTexasZipcode w/NULL value.
|
||||
SouthTexasZipcode.objects.create(name='78212')
|
||||
# Performing distance/area queries against the NULL PolygonField,
|
||||
# and ensuring the result of the operations is None.
|
||||
htown = SouthTexasCity.objects.get(name='Downtown Houston')
|
||||
z = SouthTexasZipcode.objects.distance(htown.point).area().get(name='78212')
|
||||
self.assertIsNone(z.distance)
|
||||
self.assertIsNone(z.area)
|
||||
@@ -1,65 +0,0 @@
|
||||
from django.contrib.gis.db import models
|
||||
from django.utils.encoding import python_2_unicode_compatible
|
||||
|
||||
|
||||
@python_2_unicode_compatible
|
||||
class NamedModel(models.Model):
|
||||
name = models.CharField(max_length=30)
|
||||
|
||||
objects = models.GeoManager()
|
||||
|
||||
class Meta:
|
||||
abstract = True
|
||||
app_label = 'geo3d'
|
||||
|
||||
def __str__(self):
|
||||
return self.name
|
||||
|
||||
|
||||
class City3D(NamedModel):
|
||||
point = models.PointField(dim=3)
|
||||
|
||||
|
||||
class Interstate2D(NamedModel):
|
||||
line = models.LineStringField(srid=4269)
|
||||
|
||||
|
||||
class Interstate3D(NamedModel):
|
||||
line = models.LineStringField(dim=3, srid=4269)
|
||||
|
||||
|
||||
class InterstateProj2D(NamedModel):
|
||||
line = models.LineStringField(srid=32140)
|
||||
|
||||
|
||||
class InterstateProj3D(NamedModel):
|
||||
line = models.LineStringField(dim=3, srid=32140)
|
||||
|
||||
|
||||
class Polygon2D(NamedModel):
|
||||
poly = models.PolygonField(srid=32140)
|
||||
|
||||
|
||||
class Polygon3D(NamedModel):
|
||||
poly = models.PolygonField(dim=3, srid=32140)
|
||||
|
||||
|
||||
class SimpleModel(models.Model):
|
||||
|
||||
objects = models.GeoManager()
|
||||
|
||||
class Meta:
|
||||
abstract = True
|
||||
app_label = 'geo3d'
|
||||
|
||||
|
||||
class Point2D(SimpleModel):
|
||||
point = models.PointField()
|
||||
|
||||
|
||||
class Point3D(SimpleModel):
|
||||
point = models.PointField(dim=3)
|
||||
|
||||
|
||||
class MultiPoint3D(SimpleModel):
|
||||
mpoint = models.MultiPointField(dim=3)
|
||||
@@ -1,298 +0,0 @@
|
||||
from __future__ import unicode_literals
|
||||
|
||||
import os
|
||||
import re
|
||||
from unittest import skipUnless
|
||||
|
||||
from django.contrib.gis.gdal import HAS_GDAL
|
||||
from django.contrib.gis.geos import HAS_GEOS
|
||||
from django.test import TestCase, ignore_warnings, skipUnlessDBFeature
|
||||
from django.utils._os import upath
|
||||
from django.utils.deprecation import RemovedInDjango20Warning
|
||||
|
||||
if HAS_GEOS:
|
||||
from django.contrib.gis.db.models import Union, Extent3D
|
||||
from django.contrib.gis.geos import GEOSGeometry, LineString, Point, Polygon
|
||||
|
||||
from .models import (City3D, Interstate2D, Interstate3D, InterstateProj2D,
|
||||
InterstateProj3D, Point2D, Point3D, MultiPoint3D, Polygon2D, Polygon3D)
|
||||
|
||||
if HAS_GDAL:
|
||||
from django.contrib.gis.utils import LayerMapping, LayerMapError
|
||||
|
||||
|
||||
data_path = os.path.realpath(os.path.join(os.path.dirname(upath(__file__)), '..', 'data'))
|
||||
city_file = os.path.join(data_path, 'cities', 'cities.shp')
|
||||
vrt_file = os.path.join(data_path, 'test_vrt', 'test_vrt.vrt')
|
||||
|
||||
# The coordinates of each city, with Z values corresponding to their
|
||||
# altitude in meters.
|
||||
city_data = (
|
||||
('Houston', (-95.363151, 29.763374, 18)),
|
||||
('Dallas', (-96.801611, 32.782057, 147)),
|
||||
('Oklahoma City', (-97.521157, 34.464642, 380)),
|
||||
('Wellington', (174.783117, -41.315268, 14)),
|
||||
('Pueblo', (-104.609252, 38.255001, 1433)),
|
||||
('Lawrence', (-95.235060, 38.971823, 251)),
|
||||
('Chicago', (-87.650175, 41.850385, 181)),
|
||||
('Victoria', (-123.305196, 48.462611, 15)),
|
||||
)
|
||||
|
||||
# Reference mapping of city name to its altitude (Z value).
|
||||
city_dict = {name: coords for name, coords in city_data}
|
||||
|
||||
# 3D freeway data derived from the National Elevation Dataset:
|
||||
# http://seamless.usgs.gov/products/9arc.php
|
||||
interstate_data = (
|
||||
('I-45',
|
||||
'LINESTRING(-95.3708481 29.7765870 11.339,-95.3694580 29.7787980 4.536,'
|
||||
'-95.3690305 29.7797359 9.762,-95.3691886 29.7812450 12.448,'
|
||||
'-95.3696447 29.7850144 10.457,-95.3702511 29.7868518 9.418,'
|
||||
'-95.3706724 29.7881286 14.858,-95.3711632 29.7896157 15.386,'
|
||||
'-95.3714525 29.7936267 13.168,-95.3717848 29.7955007 15.104,'
|
||||
'-95.3717719 29.7969804 16.516,-95.3717305 29.7982117 13.923,'
|
||||
'-95.3717254 29.8000778 14.385,-95.3719875 29.8013539 15.160,'
|
||||
'-95.3720575 29.8026785 15.544,-95.3721321 29.8040912 14.975,'
|
||||
'-95.3722074 29.8050998 15.688,-95.3722779 29.8060430 16.099,'
|
||||
'-95.3733818 29.8076750 15.197,-95.3741563 29.8103686 17.268,'
|
||||
'-95.3749458 29.8129927 19.857,-95.3763564 29.8144557 15.435)',
|
||||
(11.339, 4.536, 9.762, 12.448, 10.457, 9.418, 14.858,
|
||||
15.386, 13.168, 15.104, 16.516, 13.923, 14.385, 15.16,
|
||||
15.544, 14.975, 15.688, 16.099, 15.197, 17.268, 19.857,
|
||||
15.435),
|
||||
),
|
||||
)
|
||||
|
||||
# Bounding box polygon for inner-loop of Houston (in projected coordinate
|
||||
# system 32140), with elevation values from the National Elevation Dataset
|
||||
# (see above).
|
||||
bbox_data = (
|
||||
'POLYGON((941527.97 4225693.20,962596.48 4226349.75,963152.57 4209023.95,'
|
||||
'942051.75 4208366.38,941527.97 4225693.20))',
|
||||
(21.71, 13.21, 9.12, 16.40, 21.71)
|
||||
)
|
||||
|
||||
|
||||
@skipUnless(HAS_GDAL, "GDAL is required for Geo3DTest.")
|
||||
@skipUnlessDBFeature("gis_enabled", "supports_3d_functions")
|
||||
class Geo3DTest(TestCase):
|
||||
"""
|
||||
Only a subset of the PostGIS routines are 3D-enabled, and this TestCase
|
||||
tries to test the features that can handle 3D and that are also
|
||||
available within GeoDjango. For more information, see the PostGIS docs
|
||||
on the routines that support 3D:
|
||||
|
||||
http://postgis.net/docs/PostGIS_Special_Functions_Index.html#PostGIS_3D_Functions
|
||||
"""
|
||||
|
||||
def _load_interstate_data(self):
|
||||
# Interstate (2D / 3D and Geographic/Projected variants)
|
||||
for name, line, exp_z in interstate_data:
|
||||
line_3d = GEOSGeometry(line, srid=4269)
|
||||
line_2d = LineString([l[:2] for l in line_3d.coords], srid=4269)
|
||||
|
||||
# Creating a geographic and projected version of the
|
||||
# interstate in both 2D and 3D.
|
||||
Interstate3D.objects.create(name=name, line=line_3d)
|
||||
InterstateProj3D.objects.create(name=name, line=line_3d)
|
||||
Interstate2D.objects.create(name=name, line=line_2d)
|
||||
InterstateProj2D.objects.create(name=name, line=line_2d)
|
||||
|
||||
def _load_city_data(self):
|
||||
for name, pnt_data in city_data:
|
||||
City3D.objects.create(name=name, point=Point(*pnt_data, srid=4326))
|
||||
|
||||
def _load_polygon_data(self):
|
||||
bbox_wkt, bbox_z = bbox_data
|
||||
bbox_2d = GEOSGeometry(bbox_wkt, srid=32140)
|
||||
bbox_3d = Polygon(tuple((x, y, z) for (x, y), z in zip(bbox_2d[0].coords, bbox_z)), srid=32140)
|
||||
Polygon2D.objects.create(name='2D BBox', poly=bbox_2d)
|
||||
Polygon3D.objects.create(name='3D BBox', poly=bbox_3d)
|
||||
|
||||
def test_3d_hasz(self):
|
||||
"""
|
||||
Make sure data is 3D and has expected Z values -- shouldn't change
|
||||
because of coordinate system.
|
||||
"""
|
||||
self._load_interstate_data()
|
||||
for name, line, exp_z in interstate_data:
|
||||
interstate = Interstate3D.objects.get(name=name)
|
||||
interstate_proj = InterstateProj3D.objects.get(name=name)
|
||||
for i in [interstate, interstate_proj]:
|
||||
self.assertTrue(i.line.hasz)
|
||||
self.assertEqual(exp_z, tuple(i.line.z))
|
||||
|
||||
self._load_city_data()
|
||||
for name, pnt_data in city_data:
|
||||
city = City3D.objects.get(name=name)
|
||||
z = pnt_data[2]
|
||||
self.assertTrue(city.point.hasz)
|
||||
self.assertEqual(z, city.point.z)
|
||||
|
||||
def test_3d_polygons(self):
|
||||
"""
|
||||
Test the creation of polygon 3D models.
|
||||
"""
|
||||
self._load_polygon_data()
|
||||
p3d = Polygon3D.objects.get(name='3D BBox')
|
||||
self.assertTrue(p3d.poly.hasz)
|
||||
self.assertIsInstance(p3d.poly, Polygon)
|
||||
self.assertEqual(p3d.poly.srid, 32140)
|
||||
|
||||
def test_3d_layermapping(self):
|
||||
"""
|
||||
Testing LayerMapping on 3D models.
|
||||
"""
|
||||
point_mapping = {'point': 'POINT'}
|
||||
mpoint_mapping = {'mpoint': 'MULTIPOINT'}
|
||||
|
||||
# The VRT is 3D, but should still be able to map sans the Z.
|
||||
lm = LayerMapping(Point2D, vrt_file, point_mapping, transform=False)
|
||||
lm.save()
|
||||
self.assertEqual(3, Point2D.objects.count())
|
||||
|
||||
# The city shapefile is 2D, and won't be able to fill the coordinates
|
||||
# in the 3D model -- thus, a LayerMapError is raised.
|
||||
self.assertRaises(LayerMapError, LayerMapping,
|
||||
Point3D, city_file, point_mapping, transform=False)
|
||||
|
||||
# 3D model should take 3D data just fine.
|
||||
lm = LayerMapping(Point3D, vrt_file, point_mapping, transform=False)
|
||||
lm.save()
|
||||
self.assertEqual(3, Point3D.objects.count())
|
||||
|
||||
# Making sure LayerMapping.make_multi works right, by converting
|
||||
# a Point25D into a MultiPoint25D.
|
||||
lm = LayerMapping(MultiPoint3D, vrt_file, mpoint_mapping, transform=False)
|
||||
lm.save()
|
||||
self.assertEqual(3, MultiPoint3D.objects.count())
|
||||
|
||||
def test_kml(self):
|
||||
"""
|
||||
Test GeoQuerySet.kml() with Z values.
|
||||
"""
|
||||
self._load_city_data()
|
||||
h = City3D.objects.kml(precision=6).get(name='Houston')
|
||||
# KML should be 3D.
|
||||
# `SELECT ST_AsKML(point, 6) FROM geo3d_city3d WHERE name = 'Houston';`
|
||||
ref_kml_regex = re.compile(r'^<Point><coordinates>-95.363\d+,29.763\d+,18</coordinates></Point>$')
|
||||
self.assertTrue(ref_kml_regex.match(h.kml))
|
||||
|
||||
def test_geojson(self):
|
||||
"""
|
||||
Test GeoQuerySet.geojson() with Z values.
|
||||
"""
|
||||
self._load_city_data()
|
||||
h = City3D.objects.geojson(precision=6).get(name='Houston')
|
||||
# GeoJSON should be 3D
|
||||
# `SELECT ST_AsGeoJSON(point, 6) FROM geo3d_city3d WHERE name='Houston';`
|
||||
ref_json_regex = re.compile(r'^{"type":"Point","coordinates":\[-95.363151,29.763374,18(\.0+)?\]}$')
|
||||
self.assertTrue(ref_json_regex.match(h.geojson))
|
||||
|
||||
def test_union(self):
|
||||
"""
|
||||
Testing the Union aggregate of 3D models.
|
||||
"""
|
||||
# PostGIS query that returned the reference EWKT for this test:
|
||||
# `SELECT ST_AsText(ST_Union(point)) FROM geo3d_city3d;`
|
||||
self._load_city_data()
|
||||
ref_ewkt = (
|
||||
'SRID=4326;MULTIPOINT(-123.305196 48.462611 15,-104.609252 38.255001 1433,'
|
||||
'-97.521157 34.464642 380,-96.801611 32.782057 147,-95.363151 29.763374 18,'
|
||||
'-95.23506 38.971823 251,-87.650175 41.850385 181,174.783117 -41.315268 14)'
|
||||
)
|
||||
ref_union = GEOSGeometry(ref_ewkt)
|
||||
union = City3D.objects.aggregate(Union('point'))['point__union']
|
||||
self.assertTrue(union.hasz)
|
||||
# Ordering of points in the resulting geometry may vary between implementations
|
||||
self.assertSetEqual({p.ewkt for p in ref_union}, {p.ewkt for p in union})
|
||||
|
||||
@ignore_warnings(category=RemovedInDjango20Warning)
|
||||
def test_extent(self):
|
||||
"""
|
||||
Testing the Extent3D aggregate for 3D models.
|
||||
"""
|
||||
self._load_city_data()
|
||||
# `SELECT ST_Extent3D(point) FROM geo3d_city3d;`
|
||||
ref_extent3d = (-123.305196, -41.315268, 14, 174.783117, 48.462611, 1433)
|
||||
extent1 = City3D.objects.aggregate(Extent3D('point'))['point__extent3d']
|
||||
extent2 = City3D.objects.extent3d()
|
||||
|
||||
def check_extent3d(extent3d, tol=6):
|
||||
for ref_val, ext_val in zip(ref_extent3d, extent3d):
|
||||
self.assertAlmostEqual(ref_val, ext_val, tol)
|
||||
|
||||
for e3d in [extent1, extent2]:
|
||||
check_extent3d(e3d)
|
||||
self.assertIsNone(City3D.objects.none().extent3d())
|
||||
self.assertIsNone(City3D.objects.none().aggregate(Extent3D('point'))['point__extent3d'])
|
||||
|
||||
def test_perimeter(self):
|
||||
"""
|
||||
Testing GeoQuerySet.perimeter() on 3D fields.
|
||||
"""
|
||||
self._load_polygon_data()
|
||||
# Reference query for values below:
|
||||
# `SELECT ST_Perimeter3D(poly), ST_Perimeter2D(poly) FROM geo3d_polygon3d;`
|
||||
ref_perim_3d = 76859.2620451
|
||||
ref_perim_2d = 76859.2577803
|
||||
tol = 6
|
||||
self.assertAlmostEqual(ref_perim_2d,
|
||||
Polygon2D.objects.perimeter().get(name='2D BBox').perimeter.m,
|
||||
tol)
|
||||
self.assertAlmostEqual(ref_perim_3d,
|
||||
Polygon3D.objects.perimeter().get(name='3D BBox').perimeter.m,
|
||||
tol)
|
||||
|
||||
def test_length(self):
|
||||
"""
|
||||
Testing GeoQuerySet.length() on 3D fields.
|
||||
"""
|
||||
# ST_Length_Spheroid Z-aware, and thus does not need to use
|
||||
# a separate function internally.
|
||||
# `SELECT ST_Length_Spheroid(line, 'SPHEROID["GRS 1980",6378137,298.257222101]')
|
||||
# FROM geo3d_interstate[2d|3d];`
|
||||
self._load_interstate_data()
|
||||
tol = 3
|
||||
ref_length_2d = 4368.1721949481
|
||||
ref_length_3d = 4368.62547052088
|
||||
self.assertAlmostEqual(ref_length_2d,
|
||||
Interstate2D.objects.length().get(name='I-45').length.m,
|
||||
tol)
|
||||
self.assertAlmostEqual(ref_length_3d,
|
||||
Interstate3D.objects.length().get(name='I-45').length.m,
|
||||
tol)
|
||||
|
||||
# Making sure `ST_Length3D` is used on for a projected
|
||||
# and 3D model rather than `ST_Length`.
|
||||
# `SELECT ST_Length(line) FROM geo3d_interstateproj2d;`
|
||||
ref_length_2d = 4367.71564892392
|
||||
# `SELECT ST_Length3D(line) FROM geo3d_interstateproj3d;`
|
||||
ref_length_3d = 4368.16897234101
|
||||
self.assertAlmostEqual(ref_length_2d,
|
||||
InterstateProj2D.objects.length().get(name='I-45').length.m,
|
||||
tol)
|
||||
self.assertAlmostEqual(ref_length_3d,
|
||||
InterstateProj3D.objects.length().get(name='I-45').length.m,
|
||||
tol)
|
||||
|
||||
def test_scale(self):
|
||||
"""
|
||||
Testing GeoQuerySet.scale() on Z values.
|
||||
"""
|
||||
self._load_city_data()
|
||||
# Mapping of City name to reference Z values.
|
||||
zscales = (-3, 4, 23)
|
||||
for zscale in zscales:
|
||||
for city in City3D.objects.scale(1.0, 1.0, zscale):
|
||||
self.assertEqual(city_dict[city.name][2] * zscale, city.scale.z)
|
||||
|
||||
def test_translate(self):
|
||||
"""
|
||||
Testing GeoQuerySet.translate() on Z values.
|
||||
"""
|
||||
self._load_city_data()
|
||||
ztranslations = (5.23, 23, -17)
|
||||
for ztrans in ztranslations:
|
||||
for city in City3D.objects.translate(0, 0, ztrans):
|
||||
self.assertEqual(city_dict[city.name][2] + ztrans, city.translate.z)
|
||||
@@ -1 +0,0 @@
|
||||
# Create your views here.
|
||||
@@ -1,5 +0,0 @@
|
||||
from django.contrib.gis import admin
|
||||
|
||||
|
||||
class UnmodifiableAdmin(admin.OSMGeoAdmin):
|
||||
modifiable = False
|
||||
@@ -1,19 +0,0 @@
|
||||
from django.contrib.gis import admin
|
||||
from django.contrib.gis.db import models
|
||||
from django.utils.encoding import python_2_unicode_compatible
|
||||
|
||||
|
||||
@python_2_unicode_compatible
|
||||
class City(models.Model):
|
||||
name = models.CharField(max_length=30)
|
||||
point = models.PointField()
|
||||
|
||||
objects = models.GeoManager()
|
||||
|
||||
class Meta:
|
||||
app_label = 'geoadmin'
|
||||
|
||||
def __str__(self):
|
||||
return self.name
|
||||
|
||||
admin.site.register(City, admin.OSMGeoAdmin)
|
||||
@@ -1,76 +0,0 @@
|
||||
from __future__ import unicode_literals
|
||||
|
||||
from django.contrib.gis.geos import HAS_GEOS
|
||||
from django.test import TestCase, override_settings, skipUnlessDBFeature
|
||||
|
||||
if HAS_GEOS:
|
||||
from django.contrib.gis import admin
|
||||
from django.contrib.gis.geos import Point
|
||||
|
||||
from .admin import UnmodifiableAdmin
|
||||
from .models import City
|
||||
|
||||
|
||||
@skipUnlessDBFeature("gis_enabled")
|
||||
@override_settings(ROOT_URLCONF='django.contrib.gis.tests.geoadmin.urls')
|
||||
class GeoAdminTest(TestCase):
|
||||
|
||||
def test_ensure_geographic_media(self):
|
||||
geoadmin = admin.site._registry[City]
|
||||
admin_js = geoadmin.media.render_js()
|
||||
self.assertTrue(any(geoadmin.openlayers_url in js for js in admin_js))
|
||||
|
||||
def test_olmap_OSM_rendering(self):
|
||||
delete_all_btn = """<a href="javascript:geodjango_point.clearFeatures()">Delete all Features</a>"""
|
||||
|
||||
original_geoadmin = admin.site._registry[City]
|
||||
params = original_geoadmin.get_map_widget(City._meta.get_field('point')).params
|
||||
result = original_geoadmin.get_map_widget(City._meta.get_field('point'))(
|
||||
).render('point', Point(-79.460734, 40.18476), params)
|
||||
self.assertIn(
|
||||
"""geodjango_point.layers.base = new OpenLayers.Layer.OSM("OpenStreetMap (Mapnik)");""",
|
||||
result)
|
||||
|
||||
self.assertIn(delete_all_btn, result)
|
||||
|
||||
admin.site.unregister(City)
|
||||
admin.site.register(City, UnmodifiableAdmin)
|
||||
try:
|
||||
geoadmin = admin.site._registry[City]
|
||||
params = geoadmin.get_map_widget(City._meta.get_field('point')).params
|
||||
result = geoadmin.get_map_widget(City._meta.get_field('point'))(
|
||||
).render('point', Point(-79.460734, 40.18476), params)
|
||||
|
||||
self.assertNotIn(delete_all_btn, result)
|
||||
finally:
|
||||
admin.site.unregister(City)
|
||||
admin.site.register(City, original_geoadmin.__class__)
|
||||
|
||||
def test_olmap_WMS_rendering(self):
|
||||
geoadmin = admin.GeoModelAdmin(City, admin.site)
|
||||
result = geoadmin.get_map_widget(City._meta.get_field('point'))(
|
||||
).render('point', Point(-79.460734, 40.18476))
|
||||
self.assertIn(
|
||||
"""geodjango_point.layers.base = new OpenLayers.Layer.WMS("OpenLayers WMS", """
|
||||
""""http://vmap0.tiles.osgeo.org/wms/vmap0", {layers: 'basic', format: 'image/jpeg'});""",
|
||||
result)
|
||||
|
||||
def test_olwidget_has_changed(self):
|
||||
"""
|
||||
Check that changes are accurately noticed by OpenLayersWidget.
|
||||
"""
|
||||
geoadmin = admin.site._registry[City]
|
||||
form = geoadmin.get_changelist_form(None)()
|
||||
has_changed = form.fields['point'].has_changed
|
||||
|
||||
initial = Point(13.4197458572965953, 52.5194108501149799, srid=4326)
|
||||
data_same = "SRID=3857;POINT(1493879.2754093995 6894592.019687599)"
|
||||
data_almost_same = "SRID=3857;POINT(1493879.2754093990 6894592.019687590)"
|
||||
data_changed = "SRID=3857;POINT(1493884.0527237 6894593.8111804)"
|
||||
|
||||
self.assertTrue(has_changed(None, data_changed))
|
||||
self.assertTrue(has_changed(initial, ""))
|
||||
self.assertFalse(has_changed(None, ""))
|
||||
self.assertFalse(has_changed(initial, data_same))
|
||||
self.assertFalse(has_changed(initial, data_almost_same))
|
||||
self.assertTrue(has_changed(initial, data_changed))
|
||||
@@ -1,6 +0,0 @@
|
||||
from django.conf.urls import include, url
|
||||
from django.contrib import admin
|
||||
|
||||
urlpatterns = [
|
||||
url(r'^admin/', include(admin.site.urls)),
|
||||
]
|
||||
@@ -1,72 +0,0 @@
|
||||
from __future__ import unicode_literals
|
||||
|
||||
from django.contrib.gis import feeds
|
||||
|
||||
from .models import City
|
||||
|
||||
|
||||
class TestGeoRSS1(feeds.Feed):
|
||||
link = '/city/'
|
||||
title = 'Test GeoDjango Cities'
|
||||
|
||||
def items(self):
|
||||
return City.objects.all()
|
||||
|
||||
def item_link(self, item):
|
||||
return '/city/%s/' % item.pk
|
||||
|
||||
def item_geometry(self, item):
|
||||
return item.point
|
||||
|
||||
|
||||
class TestGeoRSS2(TestGeoRSS1):
|
||||
def geometry(self, obj):
|
||||
# This should attach a <georss:box> element for the extent of
|
||||
# of the cities in the database. This tuple came from
|
||||
# calling `City.objects.extent()` -- we can't do that call here
|
||||
# because `extent` is not implemented for MySQL/Oracle.
|
||||
return (-123.30, -41.32, 174.78, 48.46)
|
||||
|
||||
def item_geometry(self, item):
|
||||
# Returning a simple tuple for the geometry.
|
||||
return item.point.x, item.point.y
|
||||
|
||||
|
||||
class TestGeoAtom1(TestGeoRSS1):
|
||||
feed_type = feeds.GeoAtom1Feed
|
||||
|
||||
|
||||
class TestGeoAtom2(TestGeoRSS2):
|
||||
feed_type = feeds.GeoAtom1Feed
|
||||
|
||||
def geometry(self, obj):
|
||||
# This time we'll use a 2-tuple of coordinates for the box.
|
||||
return ((-123.30, -41.32), (174.78, 48.46))
|
||||
|
||||
|
||||
class TestW3CGeo1(TestGeoRSS1):
|
||||
feed_type = feeds.W3CGeoFeed
|
||||
|
||||
|
||||
# The following feeds are invalid, and will raise exceptions.
|
||||
class TestW3CGeo2(TestGeoRSS2):
|
||||
feed_type = feeds.W3CGeoFeed
|
||||
|
||||
|
||||
class TestW3CGeo3(TestGeoRSS1):
|
||||
feed_type = feeds.W3CGeoFeed
|
||||
|
||||
def item_geometry(self, item):
|
||||
from django.contrib.gis.geos import Polygon
|
||||
return Polygon(((0, 0), (0, 1), (1, 1), (1, 0), (0, 0)))
|
||||
|
||||
# The feed dictionary to use for URLs.
|
||||
feed_dict = {
|
||||
'rss1': TestGeoRSS1,
|
||||
'rss2': TestGeoRSS2,
|
||||
'atom1': TestGeoAtom1,
|
||||
'atom2': TestGeoAtom2,
|
||||
'w3cgeo1': TestW3CGeo1,
|
||||
'w3cgeo2': TestW3CGeo2,
|
||||
'w3cgeo3': TestW3CGeo3,
|
||||
}
|
||||
Binary file not shown.
@@ -1,89 +0,0 @@
|
||||
from django.contrib.gis.db import models
|
||||
from django.contrib.gis.tests.utils import gisfield_may_be_null
|
||||
from django.utils.encoding import python_2_unicode_compatible
|
||||
|
||||
|
||||
@python_2_unicode_compatible
|
||||
class NamedModel(models.Model):
|
||||
name = models.CharField(max_length=30)
|
||||
|
||||
objects = models.GeoManager()
|
||||
|
||||
class Meta:
|
||||
abstract = True
|
||||
app_label = 'geoapp'
|
||||
|
||||
def __str__(self):
|
||||
return self.name
|
||||
|
||||
|
||||
class Country(NamedModel):
|
||||
mpoly = models.MultiPolygonField() # SRID, by default, is 4326
|
||||
|
||||
|
||||
class City(NamedModel):
|
||||
point = models.PointField()
|
||||
|
||||
|
||||
# This is an inherited model from City
|
||||
class PennsylvaniaCity(City):
|
||||
county = models.CharField(max_length=30)
|
||||
founded = models.DateTimeField(null=True)
|
||||
|
||||
# TODO: This should be implicitly inherited.
|
||||
|
||||
objects = models.GeoManager()
|
||||
|
||||
class Meta:
|
||||
app_label = 'geoapp'
|
||||
|
||||
|
||||
class State(NamedModel):
|
||||
poly = models.PolygonField(null=gisfield_may_be_null) # Allowing NULL geometries here.
|
||||
|
||||
|
||||
class Track(NamedModel):
|
||||
line = models.LineStringField()
|
||||
|
||||
|
||||
class MultiFields(NamedModel):
|
||||
city = models.ForeignKey(City)
|
||||
point = models.PointField()
|
||||
poly = models.PolygonField()
|
||||
|
||||
|
||||
class Truth(models.Model):
|
||||
val = models.BooleanField(default=False)
|
||||
|
||||
objects = models.GeoManager()
|
||||
|
||||
class Meta:
|
||||
app_label = 'geoapp'
|
||||
|
||||
|
||||
class Feature(NamedModel):
|
||||
geom = models.GeometryField()
|
||||
|
||||
|
||||
class MinusOneSRID(models.Model):
|
||||
geom = models.PointField(srid=-1) # Minus one SRID.
|
||||
|
||||
objects = models.GeoManager()
|
||||
|
||||
class Meta:
|
||||
app_label = 'geoapp'
|
||||
|
||||
|
||||
class NonConcreteField(models.IntegerField):
|
||||
|
||||
def db_type(self, connection):
|
||||
return None
|
||||
|
||||
def get_attname_column(self):
|
||||
attname, column = super(NonConcreteField, self).get_attname_column()
|
||||
return attname, None
|
||||
|
||||
|
||||
class NonConcreteModel(NamedModel):
|
||||
non_concrete = NonConcreteField()
|
||||
point = models.PointField(geography=True)
|
||||
@@ -1,7 +0,0 @@
|
||||
from django.contrib.gis.sitemaps import KMLSitemap, KMZSitemap
|
||||
|
||||
from .models import City, Country
|
||||
|
||||
sitemaps = {'kml': KMLSitemap([City, Country]),
|
||||
'kmz': KMZSitemap([City, Country]),
|
||||
}
|
||||
@@ -1,92 +0,0 @@
|
||||
from __future__ import unicode_literals
|
||||
|
||||
from xml.dom import minidom
|
||||
|
||||
from django.conf import settings
|
||||
from django.contrib.gis.geos import HAS_GEOS
|
||||
from django.contrib.sites.models import Site
|
||||
from django.test import (
|
||||
TestCase, modify_settings, override_settings, skipUnlessDBFeature,
|
||||
)
|
||||
|
||||
if HAS_GEOS:
|
||||
from .models import City
|
||||
|
||||
|
||||
@modify_settings(INSTALLED_APPS={'append': 'django.contrib.sites'})
|
||||
@override_settings(ROOT_URLCONF='django.contrib.gis.tests.geoapp.urls')
|
||||
@skipUnlessDBFeature("gis_enabled")
|
||||
class GeoFeedTest(TestCase):
|
||||
fixtures = ['initial']
|
||||
|
||||
def setUp(self):
|
||||
Site(id=settings.SITE_ID, domain="example.com", name="example.com").save()
|
||||
|
||||
def assertChildNodes(self, elem, expected):
|
||||
"Taken from syndication/tests.py."
|
||||
actual = set(n.nodeName for n in elem.childNodes)
|
||||
expected = set(expected)
|
||||
self.assertEqual(actual, expected)
|
||||
|
||||
def test_geofeed_rss(self):
|
||||
"Tests geographic feeds using GeoRSS over RSSv2."
|
||||
# Uses `GEOSGeometry` in `item_geometry`
|
||||
doc1 = minidom.parseString(self.client.get('/feeds/rss1/').content)
|
||||
# Uses a 2-tuple in `item_geometry`
|
||||
doc2 = minidom.parseString(self.client.get('/feeds/rss2/').content)
|
||||
feed1, feed2 = doc1.firstChild, doc2.firstChild
|
||||
|
||||
# Making sure the box got added to the second GeoRSS feed.
|
||||
self.assertChildNodes(feed2.getElementsByTagName('channel')[0],
|
||||
['title', 'link', 'description', 'language',
|
||||
'lastBuildDate', 'item', 'georss:box', 'atom:link']
|
||||
)
|
||||
|
||||
# Incrementing through the feeds.
|
||||
for feed in [feed1, feed2]:
|
||||
# Ensuring the georss namespace was added to the <rss> element.
|
||||
self.assertEqual(feed.getAttribute('xmlns:georss'), 'http://www.georss.org/georss')
|
||||
chan = feed.getElementsByTagName('channel')[0]
|
||||
items = chan.getElementsByTagName('item')
|
||||
self.assertEqual(len(items), City.objects.count())
|
||||
|
||||
# Ensuring the georss element was added to each item in the feed.
|
||||
for item in items:
|
||||
self.assertChildNodes(item, ['title', 'link', 'description', 'guid', 'georss:point'])
|
||||
|
||||
def test_geofeed_atom(self):
|
||||
"Testing geographic feeds using GeoRSS over Atom."
|
||||
doc1 = minidom.parseString(self.client.get('/feeds/atom1/').content)
|
||||
doc2 = minidom.parseString(self.client.get('/feeds/atom2/').content)
|
||||
feed1, feed2 = doc1.firstChild, doc2.firstChild
|
||||
|
||||
# Making sure the box got added to the second GeoRSS feed.
|
||||
self.assertChildNodes(feed2, ['title', 'link', 'id', 'updated', 'entry', 'georss:box'])
|
||||
|
||||
for feed in [feed1, feed2]:
|
||||
# Ensuring the georsss namespace was added to the <feed> element.
|
||||
self.assertEqual(feed.getAttribute('xmlns:georss'), 'http://www.georss.org/georss')
|
||||
entries = feed.getElementsByTagName('entry')
|
||||
self.assertEqual(len(entries), City.objects.count())
|
||||
|
||||
# Ensuring the georss element was added to each entry in the feed.
|
||||
for entry in entries:
|
||||
self.assertChildNodes(entry, ['title', 'link', 'id', 'summary', 'georss:point'])
|
||||
|
||||
def test_geofeed_w3c(self):
|
||||
"Testing geographic feeds using W3C Geo."
|
||||
doc = minidom.parseString(self.client.get('/feeds/w3cgeo1/').content)
|
||||
feed = doc.firstChild
|
||||
# Ensuring the geo namespace was added to the <feed> element.
|
||||
self.assertEqual(feed.getAttribute('xmlns:geo'), 'http://www.w3.org/2003/01/geo/wgs84_pos#')
|
||||
chan = feed.getElementsByTagName('channel')[0]
|
||||
items = chan.getElementsByTagName('item')
|
||||
self.assertEqual(len(items), City.objects.count())
|
||||
|
||||
# Ensuring the geo:lat and geo:lon element was added to each item in the feed.
|
||||
for item in items:
|
||||
self.assertChildNodes(item, ['title', 'link', 'description', 'guid', 'geo:lat', 'geo:lon'])
|
||||
|
||||
# Boxes and Polygons aren't allowed in W3C Geo feeds.
|
||||
self.assertRaises(ValueError, self.client.get, '/feeds/w3cgeo2/') # Box in <channel>
|
||||
self.assertRaises(ValueError, self.client.get, '/feeds/w3cgeo3/') # Polygons in <entry>
|
||||
@@ -1,91 +0,0 @@
|
||||
# -*- encoding: utf-8 -*-
|
||||
from __future__ import unicode_literals
|
||||
|
||||
from datetime import datetime
|
||||
|
||||
from django.contrib.gis.geos import HAS_GEOS
|
||||
from django.contrib.gis.shortcuts import render_to_kmz
|
||||
from django.contrib.gis.tests.utils import no_oracle
|
||||
from django.db.models import Count, Min
|
||||
from django.test import TestCase, skipUnlessDBFeature
|
||||
|
||||
if HAS_GEOS:
|
||||
from django.contrib.gis.db.models import Extent
|
||||
from .models import City, PennsylvaniaCity, State, Truth
|
||||
|
||||
|
||||
@skipUnlessDBFeature("gis_enabled")
|
||||
class GeoRegressionTests(TestCase):
|
||||
fixtures = ['initial']
|
||||
|
||||
def test_update(self):
|
||||
"Testing GeoQuerySet.update(). See #10411."
|
||||
pnt = City.objects.get(name='Pueblo').point
|
||||
bak = pnt.clone()
|
||||
pnt.y += 0.005
|
||||
pnt.x += 0.005
|
||||
|
||||
City.objects.filter(name='Pueblo').update(point=pnt)
|
||||
self.assertEqual(pnt, City.objects.get(name='Pueblo').point)
|
||||
City.objects.filter(name='Pueblo').update(point=bak)
|
||||
self.assertEqual(bak, City.objects.get(name='Pueblo').point)
|
||||
|
||||
def test_kmz(self):
|
||||
"Testing `render_to_kmz` with non-ASCII data. See #11624."
|
||||
name = "Åland Islands"
|
||||
places = [{
|
||||
'name': name,
|
||||
'description': name,
|
||||
'kml': '<Point><coordinates>5.0,23.0</coordinates></Point>'
|
||||
}]
|
||||
render_to_kmz('gis/kml/placemarks.kml', {'places': places})
|
||||
|
||||
@skipUnlessDBFeature("supports_extent_aggr")
|
||||
def test_extent(self):
|
||||
"Testing `extent` on a table with a single point. See #11827."
|
||||
pnt = City.objects.get(name='Pueblo').point
|
||||
ref_ext = (pnt.x, pnt.y, pnt.x, pnt.y)
|
||||
extent = City.objects.filter(name='Pueblo').aggregate(Extent('point'))['point__extent']
|
||||
for ref_val, val in zip(ref_ext, extent):
|
||||
self.assertAlmostEqual(ref_val, val, 4)
|
||||
|
||||
def test_unicode_date(self):
|
||||
"Testing dates are converted properly, even on SpatiaLite. See #16408."
|
||||
founded = datetime(1857, 5, 23)
|
||||
PennsylvaniaCity.objects.create(name='Mansfield', county='Tioga', point='POINT(-77.071445 41.823881)',
|
||||
founded=founded)
|
||||
self.assertEqual(founded, PennsylvaniaCity.objects.datetimes('founded', 'day')[0])
|
||||
self.assertEqual(founded, PennsylvaniaCity.objects.aggregate(Min('founded'))['founded__min'])
|
||||
|
||||
def test_empty_count(self):
|
||||
"Testing that PostGISAdapter.__eq__ does check empty strings. See #13670."
|
||||
# contrived example, but need a geo lookup paired with an id__in lookup
|
||||
pueblo = City.objects.get(name='Pueblo')
|
||||
state = State.objects.filter(poly__contains=pueblo.point)
|
||||
cities_within_state = City.objects.filter(id__in=state)
|
||||
|
||||
# .count() should not throw TypeError in __eq__
|
||||
self.assertEqual(cities_within_state.count(), 1)
|
||||
|
||||
# TODO: fix on Oracle -- get the following error because the SQL is ordered
|
||||
# by a geometry object, which Oracle apparently doesn't like:
|
||||
# ORA-22901: cannot compare nested table or VARRAY or LOB attributes of an object type
|
||||
@no_oracle
|
||||
def test_defer_or_only_with_annotate(self):
|
||||
"Regression for #16409. Make sure defer() and only() work with annotate()"
|
||||
self.assertIsInstance(list(City.objects.annotate(Count('point')).defer('name')), list)
|
||||
self.assertIsInstance(list(City.objects.annotate(Count('point')).only('name')), list)
|
||||
|
||||
def test_boolean_conversion(self):
|
||||
"Testing Boolean value conversion with the spatial backend, see #15169."
|
||||
t1 = Truth.objects.create(val=True)
|
||||
t2 = Truth.objects.create(val=False)
|
||||
|
||||
val1 = Truth.objects.get(pk=t1.pk).val
|
||||
val2 = Truth.objects.get(pk=t2.pk).val
|
||||
# verify types -- shouldn't be 0/1
|
||||
self.assertIsInstance(val1, bool)
|
||||
self.assertIsInstance(val2, bool)
|
||||
# verify values
|
||||
self.assertEqual(val1, True)
|
||||
self.assertEqual(val2, False)
|
||||
@@ -1,80 +0,0 @@
|
||||
from __future__ import unicode_literals
|
||||
|
||||
import json
|
||||
|
||||
from django.contrib.gis.geos import HAS_GEOS
|
||||
from django.core import serializers
|
||||
from django.test import TestCase, skipUnlessDBFeature
|
||||
|
||||
if HAS_GEOS:
|
||||
from django.contrib.gis.geos import LinearRing, Point, Polygon
|
||||
from .models import City, MultiFields, PennsylvaniaCity
|
||||
|
||||
|
||||
@skipUnlessDBFeature("gis_enabled")
|
||||
class GeoJSONSerializerTests(TestCase):
|
||||
fixtures = ['initial']
|
||||
|
||||
def test_builtin_serializers(self):
|
||||
"""
|
||||
'geojson' should be listed in available serializers.
|
||||
"""
|
||||
all_formats = set(serializers.get_serializer_formats())
|
||||
public_formats = set(serializers.get_public_serializer_formats())
|
||||
|
||||
self.assertIn('geojson', all_formats),
|
||||
self.assertIn('geojson', public_formats)
|
||||
|
||||
def test_serialization_base(self):
|
||||
geojson = serializers.serialize('geojson', City.objects.all().order_by('name'))
|
||||
try:
|
||||
geodata = json.loads(geojson)
|
||||
except Exception:
|
||||
self.fail("Serialized output is not valid JSON")
|
||||
self.assertEqual(len(geodata['features']), len(City.objects.all()))
|
||||
self.assertEqual(geodata['features'][0]['geometry']['type'], 'Point')
|
||||
self.assertEqual(geodata['features'][0]['properties']['name'], 'Chicago')
|
||||
|
||||
def test_geometry_field_option(self):
|
||||
"""
|
||||
When a model has several geometry fields, the 'geometry_field' option
|
||||
can be used to specify the field to use as the 'geometry' key.
|
||||
"""
|
||||
MultiFields.objects.create(
|
||||
city=City.objects.first(), name='Name', point=Point(5, 23),
|
||||
poly=Polygon(LinearRing((0, 0), (0, 5), (5, 5), (5, 0), (0, 0))))
|
||||
|
||||
geojson = serializers.serialize('geojson', MultiFields.objects.all())
|
||||
geodata = json.loads(geojson)
|
||||
self.assertEqual(geodata['features'][0]['geometry']['type'], 'Point')
|
||||
|
||||
geojson = serializers.serialize('geojson', MultiFields.objects.all(),
|
||||
geometry_field='poly')
|
||||
geodata = json.loads(geojson)
|
||||
self.assertEqual(geodata['features'][0]['geometry']['type'], 'Polygon')
|
||||
|
||||
def test_fields_option(self):
|
||||
"""
|
||||
The fields option allows to define a subset of fields to be present in
|
||||
the 'properties' of the generated output.
|
||||
"""
|
||||
PennsylvaniaCity.objects.create(name='Mansfield', county='Tioga', point='POINT(-77.071445 41.823881)')
|
||||
geojson = serializers.serialize('geojson', PennsylvaniaCity.objects.all(),
|
||||
fields=('county', 'point'))
|
||||
geodata = json.loads(geojson)
|
||||
self.assertIn('county', geodata['features'][0]['properties'])
|
||||
self.assertNotIn('founded', geodata['features'][0]['properties'])
|
||||
|
||||
def test_srid_option(self):
|
||||
geojson = serializers.serialize('geojson', City.objects.all().order_by('name'), srid=2847)
|
||||
geodata = json.loads(geojson)
|
||||
self.assertEqual(
|
||||
[int(c) for c in geodata['features'][0]['geometry']['coordinates']],
|
||||
[1564802, 5613214])
|
||||
|
||||
def test_deserialization_exception(self):
|
||||
"""
|
||||
GeoJSON cannot be deserialized.
|
||||
"""
|
||||
with self.assertRaises(serializers.base.SerializerDoesNotExist):
|
||||
serializers.deserialize('geojson', '{}')
|
||||
@@ -1,75 +0,0 @@
|
||||
from __future__ import unicode_literals
|
||||
|
||||
import zipfile
|
||||
from io import BytesIO
|
||||
from xml.dom import minidom
|
||||
|
||||
from django.conf import settings
|
||||
from django.contrib.gis.geos import HAS_GEOS
|
||||
from django.contrib.sites.models import Site
|
||||
from django.test import (
|
||||
TestCase, ignore_warnings, modify_settings, override_settings,
|
||||
skipUnlessDBFeature,
|
||||
)
|
||||
from django.utils.deprecation import RemovedInDjango20Warning
|
||||
|
||||
if HAS_GEOS:
|
||||
from .models import City, Country
|
||||
|
||||
|
||||
@modify_settings(INSTALLED_APPS={'append': ['django.contrib.sites', 'django.contrib.sitemaps']})
|
||||
@override_settings(ROOT_URLCONF='django.contrib.gis.tests.geoapp.urls')
|
||||
@skipUnlessDBFeature("gis_enabled")
|
||||
class GeoSitemapTest(TestCase):
|
||||
|
||||
def setUp(self):
|
||||
super(GeoSitemapTest, self).setUp()
|
||||
Site(id=settings.SITE_ID, domain="example.com", name="example.com").save()
|
||||
|
||||
def assertChildNodes(self, elem, expected):
|
||||
"Taken from syndication/tests.py."
|
||||
actual = set(n.nodeName for n in elem.childNodes)
|
||||
expected = set(expected)
|
||||
self.assertEqual(actual, expected)
|
||||
|
||||
@ignore_warnings(category=RemovedInDjango20Warning)
|
||||
def test_geositemap_kml(self):
|
||||
"Tests KML/KMZ geographic sitemaps."
|
||||
for kml_type in ('kml', 'kmz'):
|
||||
# The URL for the sitemaps in urls.py have been updated
|
||||
# with a name but since reversing by Python path is tried first
|
||||
# before reversing by name and works since we're giving
|
||||
# name='django.contrib.gis.sitemaps.views.(kml|kmz)', we need
|
||||
# to silence the erroneous warning until reversing by dotted
|
||||
# path is removed. The test will work without modification when
|
||||
# it's removed.
|
||||
doc = minidom.parseString(self.client.get('/sitemaps/%s.xml' % kml_type).content)
|
||||
|
||||
# Ensuring the right sitemaps namespace is present.
|
||||
urlset = doc.firstChild
|
||||
self.assertEqual(urlset.getAttribute('xmlns'), 'http://www.sitemaps.org/schemas/sitemap/0.9')
|
||||
|
||||
urls = urlset.getElementsByTagName('url')
|
||||
self.assertEqual(2, len(urls)) # Should only be 2 sitemaps.
|
||||
for url in urls:
|
||||
self.assertChildNodes(url, ['loc'])
|
||||
|
||||
# Getting the relative URL since we don't have a real site.
|
||||
kml_url = url.getElementsByTagName('loc')[0].childNodes[0].data.split('http://example.com')[1]
|
||||
|
||||
if kml_type == 'kml':
|
||||
kml_doc = minidom.parseString(self.client.get(kml_url).content)
|
||||
elif kml_type == 'kmz':
|
||||
# Have to decompress KMZ before parsing.
|
||||
buf = BytesIO(self.client.get(kml_url).content)
|
||||
zf = zipfile.ZipFile(buf)
|
||||
self.assertEqual(1, len(zf.filelist))
|
||||
self.assertEqual('doc.kml', zf.filelist[0].filename)
|
||||
kml_doc = minidom.parseString(zf.read('doc.kml'))
|
||||
|
||||
# Ensuring the correct number of placemarks are in the KML doc.
|
||||
if 'city' in kml_url:
|
||||
model = City
|
||||
elif 'country' in kml_url:
|
||||
model = Country
|
||||
self.assertEqual(model.objects.count(), len(kml_doc.getElementsByTagName('Placemark')))
|
||||
@@ -1,912 +0,0 @@
|
||||
from __future__ import unicode_literals
|
||||
|
||||
import re
|
||||
from tempfile import NamedTemporaryFile
|
||||
|
||||
from django.contrib.gis import gdal
|
||||
from django.contrib.gis.geos import HAS_GEOS
|
||||
from django.contrib.gis.tests.utils import (
|
||||
no_oracle, oracle, postgis, spatialite,
|
||||
)
|
||||
from django.core.management import call_command
|
||||
from django.db import connection
|
||||
from django.test import TestCase, ignore_warnings, skipUnlessDBFeature
|
||||
from django.utils import six
|
||||
from django.utils.deprecation import RemovedInDjango20Warning
|
||||
|
||||
if HAS_GEOS:
|
||||
from django.contrib.gis.db.models import Extent, MakeLine, Union
|
||||
from django.contrib.gis.geos import (fromstr, GEOSGeometry,
|
||||
Point, LineString, LinearRing, Polygon, GeometryCollection)
|
||||
from .models import Country, City, PennsylvaniaCity, State, Track, NonConcreteModel, Feature, MinusOneSRID
|
||||
|
||||
|
||||
def postgis_bug_version():
|
||||
spatial_version = getattr(connection.ops, "spatial_version", (0, 0, 0))
|
||||
return spatial_version and (2, 0, 0) <= spatial_version <= (2, 0, 1)
|
||||
|
||||
|
||||
@skipUnlessDBFeature("gis_enabled")
|
||||
class GeoModelTest(TestCase):
|
||||
fixtures = ['initial']
|
||||
|
||||
def test_fixtures(self):
|
||||
"Testing geographic model initialization from fixtures."
|
||||
# Ensuring that data was loaded from initial data fixtures.
|
||||
self.assertEqual(2, Country.objects.count())
|
||||
self.assertEqual(8, City.objects.count())
|
||||
self.assertEqual(2, State.objects.count())
|
||||
|
||||
def test_proxy(self):
|
||||
"Testing Lazy-Geometry support (using the GeometryProxy)."
|
||||
# Testing on a Point
|
||||
pnt = Point(0, 0)
|
||||
nullcity = City(name='NullCity', point=pnt)
|
||||
nullcity.save()
|
||||
|
||||
# Making sure TypeError is thrown when trying to set with an
|
||||
# incompatible type.
|
||||
for bad in [5, 2.0, LineString((0, 0), (1, 1))]:
|
||||
try:
|
||||
nullcity.point = bad
|
||||
except TypeError:
|
||||
pass
|
||||
else:
|
||||
self.fail('Should throw a TypeError')
|
||||
|
||||
# Now setting with a compatible GEOS Geometry, saving, and ensuring
|
||||
# the save took, notice no SRID is explicitly set.
|
||||
new = Point(5, 23)
|
||||
nullcity.point = new
|
||||
|
||||
# Ensuring that the SRID is automatically set to that of the
|
||||
# field after assignment, but before saving.
|
||||
self.assertEqual(4326, nullcity.point.srid)
|
||||
nullcity.save()
|
||||
|
||||
# Ensuring the point was saved correctly after saving
|
||||
self.assertEqual(new, City.objects.get(name='NullCity').point)
|
||||
|
||||
# Setting the X and Y of the Point
|
||||
nullcity.point.x = 23
|
||||
nullcity.point.y = 5
|
||||
# Checking assignments pre & post-save.
|
||||
self.assertNotEqual(Point(23, 5), City.objects.get(name='NullCity').point)
|
||||
nullcity.save()
|
||||
self.assertEqual(Point(23, 5), City.objects.get(name='NullCity').point)
|
||||
nullcity.delete()
|
||||
|
||||
# Testing on a Polygon
|
||||
shell = LinearRing((0, 0), (0, 100), (100, 100), (100, 0), (0, 0))
|
||||
inner = LinearRing((40, 40), (40, 60), (60, 60), (60, 40), (40, 40))
|
||||
|
||||
# Creating a State object using a built Polygon
|
||||
ply = Polygon(shell, inner)
|
||||
nullstate = State(name='NullState', poly=ply)
|
||||
self.assertEqual(4326, nullstate.poly.srid) # SRID auto-set from None
|
||||
nullstate.save()
|
||||
|
||||
ns = State.objects.get(name='NullState')
|
||||
self.assertEqual(ply, ns.poly)
|
||||
|
||||
# Testing the `ogr` and `srs` lazy-geometry properties.
|
||||
if gdal.HAS_GDAL:
|
||||
self.assertIsInstance(ns.poly.ogr, gdal.OGRGeometry)
|
||||
self.assertEqual(ns.poly.wkb, ns.poly.ogr.wkb)
|
||||
self.assertIsInstance(ns.poly.srs, gdal.SpatialReference)
|
||||
self.assertEqual('WGS 84', ns.poly.srs.name)
|
||||
|
||||
# Changing the interior ring on the poly attribute.
|
||||
new_inner = LinearRing((30, 30), (30, 70), (70, 70), (70, 30), (30, 30))
|
||||
ns.poly[1] = new_inner
|
||||
ply[1] = new_inner
|
||||
self.assertEqual(4326, ns.poly.srid)
|
||||
ns.save()
|
||||
self.assertEqual(ply, State.objects.get(name='NullState').poly)
|
||||
ns.delete()
|
||||
|
||||
@skipUnlessDBFeature("supports_transform")
|
||||
def test_lookup_insert_transform(self):
|
||||
"Testing automatic transform for lookups and inserts."
|
||||
# San Antonio in 'WGS84' (SRID 4326)
|
||||
sa_4326 = 'POINT (-98.493183 29.424170)'
|
||||
wgs_pnt = fromstr(sa_4326, srid=4326) # Our reference point in WGS84
|
||||
|
||||
# Oracle doesn't have SRID 3084, using 41157.
|
||||
if oracle:
|
||||
# San Antonio in 'Texas 4205, Southern Zone (1983, meters)' (SRID 41157)
|
||||
# Used the following Oracle SQL to get this value:
|
||||
# SELECT SDO_UTIL.TO_WKTGEOMETRY(
|
||||
# SDO_CS.TRANSFORM(SDO_GEOMETRY('POINT (-98.493183 29.424170)', 4326), 41157))
|
||||
# )
|
||||
# FROM DUAL;
|
||||
nad_wkt = 'POINT (300662.034646583 5416427.45974934)'
|
||||
nad_srid = 41157
|
||||
else:
|
||||
# San Antonio in 'NAD83(HARN) / Texas Centric Lambert Conformal' (SRID 3084)
|
||||
# Used ogr.py in gdal 1.4.1 for this transform
|
||||
nad_wkt = 'POINT (1645978.362408288754523 6276356.025927528738976)'
|
||||
nad_srid = 3084
|
||||
|
||||
# Constructing & querying with a point from a different SRID. Oracle
|
||||
# `SDO_OVERLAPBDYINTERSECT` operates differently from
|
||||
# `ST_Intersects`, so contains is used instead.
|
||||
nad_pnt = fromstr(nad_wkt, srid=nad_srid)
|
||||
if oracle:
|
||||
tx = Country.objects.get(mpoly__contains=nad_pnt)
|
||||
else:
|
||||
tx = Country.objects.get(mpoly__intersects=nad_pnt)
|
||||
self.assertEqual('Texas', tx.name)
|
||||
|
||||
# Creating San Antonio. Remember the Alamo.
|
||||
sa = City.objects.create(name='San Antonio', point=nad_pnt)
|
||||
|
||||
# Now verifying that San Antonio was transformed correctly
|
||||
sa = City.objects.get(name='San Antonio')
|
||||
self.assertAlmostEqual(wgs_pnt.x, sa.point.x, 6)
|
||||
self.assertAlmostEqual(wgs_pnt.y, sa.point.y, 6)
|
||||
|
||||
# If the GeometryField SRID is -1, then we shouldn't perform any
|
||||
# transformation if the SRID of the input geometry is different.
|
||||
if spatialite and connection.ops.spatial_version < (3, 0, 0):
|
||||
# SpatiaLite < 3 does not support missing SRID values.
|
||||
return
|
||||
m1 = MinusOneSRID(geom=Point(17, 23, srid=4326))
|
||||
m1.save()
|
||||
self.assertEqual(-1, m1.geom.srid)
|
||||
|
||||
def test_createnull(self):
|
||||
"Testing creating a model instance and the geometry being None"
|
||||
c = City()
|
||||
self.assertEqual(c.point, None)
|
||||
|
||||
def test_geometryfield(self):
|
||||
"Testing the general GeometryField."
|
||||
Feature(name='Point', geom=Point(1, 1)).save()
|
||||
Feature(name='LineString', geom=LineString((0, 0), (1, 1), (5, 5))).save()
|
||||
Feature(name='Polygon', geom=Polygon(LinearRing((0, 0), (0, 5), (5, 5), (5, 0), (0, 0)))).save()
|
||||
Feature(name='GeometryCollection',
|
||||
geom=GeometryCollection(Point(2, 2), LineString((0, 0), (2, 2)),
|
||||
Polygon(LinearRing((0, 0), (0, 5), (5, 5), (5, 0), (0, 0))))).save()
|
||||
|
||||
f_1 = Feature.objects.get(name='Point')
|
||||
self.assertIsInstance(f_1.geom, Point)
|
||||
self.assertEqual((1.0, 1.0), f_1.geom.tuple)
|
||||
f_2 = Feature.objects.get(name='LineString')
|
||||
self.assertIsInstance(f_2.geom, LineString)
|
||||
self.assertEqual(((0.0, 0.0), (1.0, 1.0), (5.0, 5.0)), f_2.geom.tuple)
|
||||
|
||||
f_3 = Feature.objects.get(name='Polygon')
|
||||
self.assertIsInstance(f_3.geom, Polygon)
|
||||
f_4 = Feature.objects.get(name='GeometryCollection')
|
||||
self.assertIsInstance(f_4.geom, GeometryCollection)
|
||||
self.assertEqual(f_3.geom, f_4.geom[2])
|
||||
|
||||
@skipUnlessDBFeature("supports_transform")
|
||||
def test_inherited_geofields(self):
|
||||
"Test GeoQuerySet methods on inherited Geometry fields."
|
||||
# Creating a Pennsylvanian city.
|
||||
PennsylvaniaCity.objects.create(name='Mansfield', county='Tioga', point='POINT(-77.071445 41.823881)')
|
||||
|
||||
# All transformation SQL will need to be performed on the
|
||||
# _parent_ table.
|
||||
qs = PennsylvaniaCity.objects.transform(32128)
|
||||
|
||||
self.assertEqual(1, qs.count())
|
||||
for pc in qs:
|
||||
self.assertEqual(32128, pc.point.srid)
|
||||
|
||||
def test_raw_sql_query(self):
|
||||
"Testing raw SQL query."
|
||||
cities1 = City.objects.all()
|
||||
# Only PostGIS would support a 'select *' query because of its recognized
|
||||
# HEXEWKB format for geometry fields
|
||||
as_text = 'ST_AsText(%s)' if postgis else connection.ops.select
|
||||
cities2 = City.objects.raw(
|
||||
'select id, name, %s from geoapp_city' % as_text % 'point'
|
||||
)
|
||||
self.assertEqual(len(cities1), len(list(cities2)))
|
||||
self.assertIsInstance(cities2[0].point, Point)
|
||||
|
||||
def test_dumpdata_loaddata_cycle(self):
|
||||
"""
|
||||
Test a dumpdata/loaddata cycle with geographic data.
|
||||
"""
|
||||
out = six.StringIO()
|
||||
original_data = list(City.objects.all().order_by('name'))
|
||||
call_command('dumpdata', 'geoapp.City', stdout=out)
|
||||
result = out.getvalue()
|
||||
houston = City.objects.get(name='Houston')
|
||||
self.assertIn('"point": "%s"' % houston.point.ewkt, result)
|
||||
|
||||
# Reload now dumped data
|
||||
with NamedTemporaryFile(mode='w', suffix='.json') as tempfile:
|
||||
tempfile.write(result)
|
||||
tempfile.seek(0)
|
||||
call_command('loaddata', tempfile.name, verbosity=0)
|
||||
self.assertListEqual(original_data, list(City.objects.all().order_by('name')))
|
||||
|
||||
|
||||
@skipUnlessDBFeature("gis_enabled")
|
||||
class GeoLookupTest(TestCase):
|
||||
fixtures = ['initial']
|
||||
|
||||
def test_disjoint_lookup(self):
|
||||
"Testing the `disjoint` lookup type."
|
||||
ptown = City.objects.get(name='Pueblo')
|
||||
qs1 = City.objects.filter(point__disjoint=ptown.point)
|
||||
self.assertEqual(7, qs1.count())
|
||||
|
||||
if connection.features.supports_real_shape_operations:
|
||||
qs2 = State.objects.filter(poly__disjoint=ptown.point)
|
||||
self.assertEqual(1, qs2.count())
|
||||
self.assertEqual('Kansas', qs2[0].name)
|
||||
|
||||
def test_contains_contained_lookups(self):
|
||||
"Testing the 'contained', 'contains', and 'bbcontains' lookup types."
|
||||
# Getting Texas, yes we were a country -- once ;)
|
||||
texas = Country.objects.get(name='Texas')
|
||||
|
||||
# Seeing what cities are in Texas, should get Houston and Dallas,
|
||||
# and Oklahoma City because 'contained' only checks on the
|
||||
# _bounding box_ of the Geometries.
|
||||
if connection.features.supports_contained_lookup:
|
||||
qs = City.objects.filter(point__contained=texas.mpoly)
|
||||
self.assertEqual(3, qs.count())
|
||||
cities = ['Houston', 'Dallas', 'Oklahoma City']
|
||||
for c in qs:
|
||||
self.assertIn(c.name, cities)
|
||||
|
||||
# Pulling out some cities.
|
||||
houston = City.objects.get(name='Houston')
|
||||
wellington = City.objects.get(name='Wellington')
|
||||
pueblo = City.objects.get(name='Pueblo')
|
||||
okcity = City.objects.get(name='Oklahoma City')
|
||||
lawrence = City.objects.get(name='Lawrence')
|
||||
|
||||
# Now testing contains on the countries using the points for
|
||||
# Houston and Wellington.
|
||||
tx = Country.objects.get(mpoly__contains=houston.point) # Query w/GEOSGeometry
|
||||
nz = Country.objects.get(mpoly__contains=wellington.point.hex) # Query w/EWKBHEX
|
||||
self.assertEqual('Texas', tx.name)
|
||||
self.assertEqual('New Zealand', nz.name)
|
||||
|
||||
# Spatialite 2.3 thinks that Lawrence is in Puerto Rico (a NULL geometry).
|
||||
if not (spatialite and connection.ops.spatial_version < (3, 0, 0)):
|
||||
ks = State.objects.get(poly__contains=lawrence.point)
|
||||
self.assertEqual('Kansas', ks.name)
|
||||
|
||||
# Pueblo and Oklahoma City (even though OK City is within the bounding box of Texas)
|
||||
# are not contained in Texas or New Zealand.
|
||||
self.assertEqual(len(Country.objects.filter(mpoly__contains=pueblo.point)), 0) # Query w/GEOSGeometry object
|
||||
self.assertEqual(len(Country.objects.filter(mpoly__contains=okcity.point.wkt)),
|
||||
0 if connection.features.supports_real_shape_operations else 1) # Query w/WKT
|
||||
|
||||
# OK City is contained w/in bounding box of Texas.
|
||||
if connection.features.supports_bbcontains_lookup:
|
||||
qs = Country.objects.filter(mpoly__bbcontains=okcity.point)
|
||||
self.assertEqual(1, len(qs))
|
||||
self.assertEqual('Texas', qs[0].name)
|
||||
|
||||
@skipUnlessDBFeature("supports_crosses_lookup")
|
||||
def test_crosses_lookup(self):
|
||||
Track.objects.create(
|
||||
name='Line1',
|
||||
line=LineString([(-95, 29), (-60, 0)])
|
||||
)
|
||||
self.assertEqual(
|
||||
Track.objects.filter(line__crosses=LineString([(-95, 0), (-60, 29)])).count(),
|
||||
1
|
||||
)
|
||||
self.assertEqual(
|
||||
Track.objects.filter(line__crosses=LineString([(-95, 30), (0, 30)])).count(),
|
||||
0
|
||||
)
|
||||
|
||||
@skipUnlessDBFeature("supports_left_right_lookups")
|
||||
def test_left_right_lookups(self):
|
||||
"Testing the 'left' and 'right' lookup types."
|
||||
# Left: A << B => true if xmax(A) < xmin(B)
|
||||
# Right: A >> B => true if xmin(A) > xmax(B)
|
||||
# See: BOX2D_left() and BOX2D_right() in lwgeom_box2dfloat4.c in PostGIS source.
|
||||
|
||||
# The left/right lookup tests are known failures on PostGIS 2.0/2.0.1
|
||||
# http://trac.osgeo.org/postgis/ticket/2035
|
||||
if postgis_bug_version():
|
||||
self.skipTest("PostGIS 2.0/2.0.1 left and right lookups are known to be buggy.")
|
||||
|
||||
# Getting the borders for Colorado & Kansas
|
||||
co_border = State.objects.get(name='Colorado').poly
|
||||
ks_border = State.objects.get(name='Kansas').poly
|
||||
|
||||
# Note: Wellington has an 'X' value of 174, so it will not be considered
|
||||
# to the left of CO.
|
||||
|
||||
# These cities should be strictly to the right of the CO border.
|
||||
cities = ['Houston', 'Dallas', 'Oklahoma City',
|
||||
'Lawrence', 'Chicago', 'Wellington']
|
||||
qs = City.objects.filter(point__right=co_border)
|
||||
self.assertEqual(6, len(qs))
|
||||
for c in qs:
|
||||
self.assertIn(c.name, cities)
|
||||
|
||||
# These cities should be strictly to the right of the KS border.
|
||||
cities = ['Chicago', 'Wellington']
|
||||
qs = City.objects.filter(point__right=ks_border)
|
||||
self.assertEqual(2, len(qs))
|
||||
for c in qs:
|
||||
self.assertIn(c.name, cities)
|
||||
|
||||
# Note: Wellington has an 'X' value of 174, so it will not be considered
|
||||
# to the left of CO.
|
||||
vic = City.objects.get(point__left=co_border)
|
||||
self.assertEqual('Victoria', vic.name)
|
||||
|
||||
cities = ['Pueblo', 'Victoria']
|
||||
qs = City.objects.filter(point__left=ks_border)
|
||||
self.assertEqual(2, len(qs))
|
||||
for c in qs:
|
||||
self.assertIn(c.name, cities)
|
||||
|
||||
def test_equals_lookups(self):
|
||||
"Testing the 'same_as' and 'equals' lookup types."
|
||||
pnt = fromstr('POINT (-95.363151 29.763374)', srid=4326)
|
||||
c1 = City.objects.get(point=pnt)
|
||||
c2 = City.objects.get(point__same_as=pnt)
|
||||
c3 = City.objects.get(point__equals=pnt)
|
||||
for c in [c1, c2, c3]:
|
||||
self.assertEqual('Houston', c.name)
|
||||
|
||||
@skipUnlessDBFeature("supports_null_geometries")
|
||||
def test_null_geometries(self):
|
||||
"Testing NULL geometry support, and the `isnull` lookup type."
|
||||
# Creating a state with a NULL boundary.
|
||||
State.objects.create(name='Puerto Rico')
|
||||
|
||||
# Querying for both NULL and Non-NULL values.
|
||||
nullqs = State.objects.filter(poly__isnull=True)
|
||||
validqs = State.objects.filter(poly__isnull=False)
|
||||
|
||||
# Puerto Rico should be NULL (it's a commonwealth unincorporated territory)
|
||||
self.assertEqual(1, len(nullqs))
|
||||
self.assertEqual('Puerto Rico', nullqs[0].name)
|
||||
|
||||
# The valid states should be Colorado & Kansas
|
||||
self.assertEqual(2, len(validqs))
|
||||
state_names = [s.name for s in validqs]
|
||||
self.assertIn('Colorado', state_names)
|
||||
self.assertIn('Kansas', state_names)
|
||||
|
||||
# Saving another commonwealth w/a NULL geometry.
|
||||
nmi = State.objects.create(name='Northern Mariana Islands', poly=None)
|
||||
self.assertEqual(nmi.poly, None)
|
||||
|
||||
# Assigning a geometry and saving -- then UPDATE back to NULL.
|
||||
nmi.poly = 'POLYGON((0 0,1 0,1 1,1 0,0 0))'
|
||||
nmi.save()
|
||||
State.objects.filter(name='Northern Mariana Islands').update(poly=None)
|
||||
self.assertIsNone(State.objects.get(name='Northern Mariana Islands').poly)
|
||||
|
||||
@skipUnlessDBFeature("supports_relate_lookup")
|
||||
def test_relate_lookup(self):
|
||||
"Testing the 'relate' lookup type."
|
||||
# To make things more interesting, we will have our Texas reference point in
|
||||
# different SRIDs.
|
||||
pnt1 = fromstr('POINT (649287.0363174 4177429.4494686)', srid=2847)
|
||||
pnt2 = fromstr('POINT(-98.4919715741052 29.4333344025053)', srid=4326)
|
||||
|
||||
# Not passing in a geometry as first param should
|
||||
# raise a type error when initializing the GeoQuerySet
|
||||
self.assertRaises(ValueError, Country.objects.filter, mpoly__relate=(23, 'foo'))
|
||||
|
||||
# Making sure the right exception is raised for the given
|
||||
# bad arguments.
|
||||
for bad_args, e in [((pnt1, 0), ValueError), ((pnt2, 'T*T***FF*', 0), ValueError)]:
|
||||
qs = Country.objects.filter(mpoly__relate=bad_args)
|
||||
self.assertRaises(e, qs.count)
|
||||
|
||||
# Relate works differently for the different backends.
|
||||
if postgis or spatialite:
|
||||
contains_mask = 'T*T***FF*'
|
||||
within_mask = 'T*F**F***'
|
||||
intersects_mask = 'T********'
|
||||
elif oracle:
|
||||
contains_mask = 'contains'
|
||||
within_mask = 'inside'
|
||||
# TODO: This is not quite the same as the PostGIS mask above
|
||||
intersects_mask = 'overlapbdyintersect'
|
||||
|
||||
# Testing contains relation mask.
|
||||
self.assertEqual('Texas', Country.objects.get(mpoly__relate=(pnt1, contains_mask)).name)
|
||||
self.assertEqual('Texas', Country.objects.get(mpoly__relate=(pnt2, contains_mask)).name)
|
||||
|
||||
# Testing within relation mask.
|
||||
ks = State.objects.get(name='Kansas')
|
||||
self.assertEqual('Lawrence', City.objects.get(point__relate=(ks.poly, within_mask)).name)
|
||||
|
||||
# Testing intersection relation mask.
|
||||
if not oracle:
|
||||
self.assertEqual('Texas', Country.objects.get(mpoly__relate=(pnt1, intersects_mask)).name)
|
||||
self.assertEqual('Texas', Country.objects.get(mpoly__relate=(pnt2, intersects_mask)).name)
|
||||
self.assertEqual('Lawrence', City.objects.get(point__relate=(ks.poly, intersects_mask)).name)
|
||||
|
||||
|
||||
@skipUnlessDBFeature("gis_enabled")
|
||||
class GeoQuerySetTest(TestCase):
|
||||
fixtures = ['initial']
|
||||
|
||||
# Please keep the tests in GeoQuerySet method's alphabetic order
|
||||
|
||||
@skipUnlessDBFeature("has_centroid_method")
|
||||
def test_centroid(self):
|
||||
"Testing the `centroid` GeoQuerySet method."
|
||||
qs = State.objects.exclude(poly__isnull=True).centroid()
|
||||
if oracle:
|
||||
tol = 0.1
|
||||
elif spatialite:
|
||||
tol = 0.000001
|
||||
else:
|
||||
tol = 0.000000001
|
||||
for s in qs:
|
||||
self.assertTrue(s.poly.centroid.equals_exact(s.centroid, tol))
|
||||
|
||||
@skipUnlessDBFeature(
|
||||
"has_difference_method", "has_intersection_method",
|
||||
"has_sym_difference_method", "has_union_method")
|
||||
def test_diff_intersection_union(self):
|
||||
"Testing the `difference`, `intersection`, `sym_difference`, and `union` GeoQuerySet methods."
|
||||
geom = Point(5, 23)
|
||||
qs = Country.objects.all().difference(geom).sym_difference(geom).union(geom)
|
||||
|
||||
# XXX For some reason SpatiaLite does something screwy with the Texas geometry here. Also,
|
||||
# XXX it doesn't like the null intersection.
|
||||
if spatialite:
|
||||
qs = qs.exclude(name='Texas')
|
||||
else:
|
||||
qs = qs.intersection(geom)
|
||||
|
||||
for c in qs:
|
||||
if oracle:
|
||||
# Should be able to execute the queries; however, they won't be the same
|
||||
# as GEOS (because Oracle doesn't use GEOS internally like PostGIS or
|
||||
# SpatiaLite).
|
||||
pass
|
||||
else:
|
||||
self.assertEqual(c.mpoly.difference(geom), c.difference)
|
||||
if not spatialite:
|
||||
self.assertEqual(c.mpoly.intersection(geom), c.intersection)
|
||||
# Ordering might differ in collections
|
||||
self.assertSetEqual(set(g.wkt for g in c.mpoly.sym_difference(geom)),
|
||||
set(g.wkt for g in c.sym_difference))
|
||||
self.assertSetEqual(set(g.wkt for g in c.mpoly.union(geom)),
|
||||
set(g.wkt for g in c.union))
|
||||
|
||||
@skipUnlessDBFeature("has_envelope_method")
|
||||
def test_envelope(self):
|
||||
"Testing the `envelope` GeoQuerySet method."
|
||||
countries = Country.objects.all().envelope()
|
||||
for country in countries:
|
||||
self.assertIsInstance(country.envelope, Polygon)
|
||||
|
||||
@skipUnlessDBFeature("supports_extent_aggr")
|
||||
@ignore_warnings(category=RemovedInDjango20Warning)
|
||||
def test_extent(self):
|
||||
"""
|
||||
Testing the (deprecated) `extent` GeoQuerySet method and the Extent
|
||||
aggregate.
|
||||
"""
|
||||
# Reference query:
|
||||
# `SELECT ST_extent(point) FROM geoapp_city WHERE (name='Houston' or name='Dallas');`
|
||||
# => BOX(-96.8016128540039 29.7633724212646,-95.3631439208984 32.7820587158203)
|
||||
expected = (-96.8016128540039, 29.7633724212646, -95.3631439208984, 32.782058715820)
|
||||
|
||||
qs = City.objects.filter(name__in=('Houston', 'Dallas'))
|
||||
extent1 = qs.extent()
|
||||
extent2 = qs.aggregate(Extent('point'))['point__extent']
|
||||
|
||||
for extent in (extent1, extent2):
|
||||
for val, exp in zip(extent, expected):
|
||||
self.assertAlmostEqual(exp, val, 4)
|
||||
self.assertIsNone(City.objects.filter(name=('Smalltown')).extent())
|
||||
self.assertIsNone(City.objects.filter(name=('Smalltown')).aggregate(Extent('point'))['point__extent'])
|
||||
|
||||
@skipUnlessDBFeature("supports_extent_aggr")
|
||||
def test_extent_with_limit(self):
|
||||
"""
|
||||
Testing if extent supports limit.
|
||||
"""
|
||||
extent1 = City.objects.all().aggregate(Extent('point'))['point__extent']
|
||||
extent2 = City.objects.all()[:3].aggregate(Extent('point'))['point__extent']
|
||||
self.assertNotEqual(extent1, extent2)
|
||||
|
||||
@skipUnlessDBFeature("has_force_rhr_method")
|
||||
def test_force_rhr(self):
|
||||
"Testing GeoQuerySet.force_rhr()."
|
||||
rings = (
|
||||
((0, 0), (5, 0), (0, 5), (0, 0)),
|
||||
((1, 1), (1, 3), (3, 1), (1, 1)),
|
||||
)
|
||||
rhr_rings = (
|
||||
((0, 0), (0, 5), (5, 0), (0, 0)),
|
||||
((1, 1), (3, 1), (1, 3), (1, 1)),
|
||||
)
|
||||
State.objects.create(name='Foo', poly=Polygon(*rings))
|
||||
s = State.objects.force_rhr().get(name='Foo')
|
||||
self.assertEqual(rhr_rings, s.force_rhr.coords)
|
||||
|
||||
@skipUnlessDBFeature("has_geohash_method")
|
||||
def test_geohash(self):
|
||||
"Testing GeoQuerySet.geohash()."
|
||||
# Reference query:
|
||||
# SELECT ST_GeoHash(point) FROM geoapp_city WHERE name='Houston';
|
||||
# SELECT ST_GeoHash(point, 5) FROM geoapp_city WHERE name='Houston';
|
||||
ref_hash = '9vk1mfq8jx0c8e0386z6'
|
||||
h1 = City.objects.geohash().get(name='Houston')
|
||||
h2 = City.objects.geohash(precision=5).get(name='Houston')
|
||||
self.assertEqual(ref_hash, h1.geohash)
|
||||
self.assertEqual(ref_hash[:5], h2.geohash)
|
||||
|
||||
def test_geojson(self):
|
||||
"Testing GeoJSON output from the database using GeoQuerySet.geojson()."
|
||||
# Only PostGIS and SpatiaLite 3.0+ support GeoJSON.
|
||||
if not connection.ops.geojson:
|
||||
self.assertRaises(NotImplementedError, Country.objects.all().geojson, field_name='mpoly')
|
||||
return
|
||||
|
||||
pueblo_json = '{"type":"Point","coordinates":[-104.609252,38.255001]}'
|
||||
houston_json = (
|
||||
'{"type":"Point","crs":{"type":"name","properties":'
|
||||
'{"name":"EPSG:4326"}},"coordinates":[-95.363151,29.763374]}'
|
||||
)
|
||||
victoria_json = (
|
||||
'{"type":"Point","bbox":[-123.30519600,48.46261100,-123.30519600,48.46261100],'
|
||||
'"coordinates":[-123.305196,48.462611]}'
|
||||
)
|
||||
chicago_json = (
|
||||
'{"type":"Point","crs":{"type":"name","properties":{"name":"EPSG:4326"}},'
|
||||
'"bbox":[-87.65018,41.85039,-87.65018,41.85039],"coordinates":[-87.65018,41.85039]}'
|
||||
)
|
||||
if spatialite:
|
||||
victoria_json = (
|
||||
'{"type":"Point","bbox":[-123.305196,48.462611,-123.305196,48.462611],'
|
||||
'"coordinates":[-123.305196,48.462611]}'
|
||||
)
|
||||
|
||||
# Precision argument should only be an integer
|
||||
self.assertRaises(TypeError, City.objects.geojson, precision='foo')
|
||||
|
||||
# Reference queries and values.
|
||||
# SELECT ST_AsGeoJson("geoapp_city"."point", 8, 0)
|
||||
# FROM "geoapp_city" WHERE "geoapp_city"."name" = 'Pueblo';
|
||||
self.assertEqual(pueblo_json, City.objects.geojson().get(name='Pueblo').geojson)
|
||||
|
||||
# SELECT ST_AsGeoJson("geoapp_city"."point", 8, 2) FROM "geoapp_city"
|
||||
# WHERE "geoapp_city"."name" = 'Houston';
|
||||
# This time we want to include the CRS by using the `crs` keyword.
|
||||
self.assertEqual(houston_json, City.objects.geojson(crs=True, model_att='json').get(name='Houston').json)
|
||||
|
||||
# SELECT ST_AsGeoJson("geoapp_city"."point", 8, 1) FROM "geoapp_city"
|
||||
# WHERE "geoapp_city"."name" = 'Houston';
|
||||
# This time we include the bounding box by using the `bbox` keyword.
|
||||
self.assertEqual(victoria_json, City.objects.geojson(bbox=True).get(name='Victoria').geojson)
|
||||
|
||||
# SELECT ST_AsGeoJson("geoapp_city"."point", 5, 3) FROM "geoapp_city"
|
||||
# WHERE "geoapp_city"."name" = 'Chicago';
|
||||
# Finally, we set every available keyword.
|
||||
self.assertEqual(
|
||||
chicago_json,
|
||||
City.objects.geojson(bbox=True, crs=True, precision=5).get(name='Chicago').geojson
|
||||
)
|
||||
|
||||
@skipUnlessDBFeature("has_gml_method")
|
||||
def test_gml(self):
|
||||
"Testing GML output from the database using GeoQuerySet.gml()."
|
||||
# Should throw a TypeError when trying to obtain GML from a
|
||||
# non-geometry field.
|
||||
qs = City.objects.all()
|
||||
self.assertRaises(TypeError, qs.gml, field_name='name')
|
||||
ptown1 = City.objects.gml(field_name='point', precision=9).get(name='Pueblo')
|
||||
ptown2 = City.objects.gml(precision=9).get(name='Pueblo')
|
||||
|
||||
if oracle:
|
||||
# No precision parameter for Oracle :-/
|
||||
gml_regex = re.compile(
|
||||
r'^<gml:Point srsName="SDO:4326" xmlns:gml="http://www.opengis.net/gml">'
|
||||
r'<gml:coordinates decimal="\." cs="," ts=" ">-104.60925\d+,38.25500\d+ '
|
||||
r'</gml:coordinates></gml:Point>'
|
||||
)
|
||||
elif spatialite and connection.ops.spatial_version < (3, 0, 0):
|
||||
# Spatialite before 3.0 has extra colon in SrsName
|
||||
gml_regex = re.compile(
|
||||
r'^<gml:Point SrsName="EPSG::4326"><gml:coordinates decimal="\." '
|
||||
r'cs="," ts=" ">-104.609251\d+,38.255001</gml:coordinates></gml:Point>'
|
||||
)
|
||||
else:
|
||||
gml_regex = re.compile(
|
||||
r'^<gml:Point srsName="EPSG:4326"><gml:coordinates>'
|
||||
r'-104\.60925\d+,38\.255001</gml:coordinates></gml:Point>'
|
||||
)
|
||||
|
||||
for ptown in [ptown1, ptown2]:
|
||||
self.assertTrue(gml_regex.match(ptown.gml))
|
||||
|
||||
if postgis:
|
||||
self.assertIn('<gml:pos srsDimension="2">', City.objects.gml(version=3).get(name='Pueblo').gml)
|
||||
|
||||
@skipUnlessDBFeature("has_kml_method")
|
||||
def test_kml(self):
|
||||
"Testing KML output from the database using GeoQuerySet.kml()."
|
||||
# Should throw a TypeError when trying to obtain KML from a
|
||||
# non-geometry field.
|
||||
qs = City.objects.all()
|
||||
self.assertRaises(TypeError, qs.kml, 'name')
|
||||
|
||||
# Ensuring the KML is as expected.
|
||||
ptown1 = City.objects.kml(field_name='point', precision=9).get(name='Pueblo')
|
||||
ptown2 = City.objects.kml(precision=9).get(name='Pueblo')
|
||||
for ptown in [ptown1, ptown2]:
|
||||
self.assertEqual('<Point><coordinates>-104.609252,38.255001</coordinates></Point>', ptown.kml)
|
||||
|
||||
@ignore_warnings(category=RemovedInDjango20Warning)
|
||||
def test_make_line(self):
|
||||
"""
|
||||
Testing the (deprecated) `make_line` GeoQuerySet method and the MakeLine
|
||||
aggregate.
|
||||
"""
|
||||
if not connection.features.supports_make_line_aggr:
|
||||
# Only PostGIS has support for the MakeLine aggregate. For other
|
||||
# backends, test that NotImplementedError is raised
|
||||
self.assertRaises(
|
||||
NotImplementedError,
|
||||
City.objects.all().aggregate, MakeLine('point')
|
||||
)
|
||||
return
|
||||
|
||||
# Ensuring that a `TypeError` is raised on models without PointFields.
|
||||
self.assertRaises(TypeError, State.objects.make_line)
|
||||
self.assertRaises(TypeError, Country.objects.make_line)
|
||||
# MakeLine on an inappropriate field returns simply None
|
||||
self.assertIsNone(State.objects.aggregate(MakeLine('poly'))['poly__makeline'])
|
||||
# Reference query:
|
||||
# SELECT AsText(ST_MakeLine(geoapp_city.point)) FROM geoapp_city;
|
||||
ref_line = GEOSGeometry(
|
||||
'LINESTRING(-95.363151 29.763374,-96.801611 32.782057,'
|
||||
'-97.521157 34.464642,174.783117 -41.315268,-104.609252 38.255001,'
|
||||
'-95.23506 38.971823,-87.650175 41.850385,-123.305196 48.462611)',
|
||||
srid=4326
|
||||
)
|
||||
# We check for equality with a tolerance of 10e-5 which is a lower bound
|
||||
# of the precisions of ref_line coordinates
|
||||
line1 = City.objects.make_line()
|
||||
line2 = City.objects.aggregate(MakeLine('point'))['point__makeline']
|
||||
for line in (line1, line2):
|
||||
self.assertTrue(ref_line.equals_exact(line, tolerance=10e-5),
|
||||
"%s != %s" % (ref_line, line))
|
||||
|
||||
@skipUnlessDBFeature("has_num_geom_method")
|
||||
def test_num_geom(self):
|
||||
"Testing the `num_geom` GeoQuerySet method."
|
||||
# Both 'countries' only have two geometries.
|
||||
for c in Country.objects.num_geom():
|
||||
self.assertEqual(2, c.num_geom)
|
||||
|
||||
for c in City.objects.filter(point__isnull=False).num_geom():
|
||||
# Oracle and PostGIS 2.0+ will return 1 for the number of
|
||||
# geometries on non-collections, whereas PostGIS < 2.0.0
|
||||
# will return None.
|
||||
if postgis and connection.ops.spatial_version < (2, 0, 0):
|
||||
self.assertIsNone(c.num_geom)
|
||||
else:
|
||||
self.assertEqual(1, c.num_geom)
|
||||
|
||||
@skipUnlessDBFeature("supports_num_points_poly")
|
||||
def test_num_points(self):
|
||||
"Testing the `num_points` GeoQuerySet method."
|
||||
for c in Country.objects.num_points():
|
||||
self.assertEqual(c.mpoly.num_points, c.num_points)
|
||||
|
||||
if not oracle:
|
||||
# Oracle cannot count vertices in Point geometries.
|
||||
for c in City.objects.num_points():
|
||||
self.assertEqual(1, c.num_points)
|
||||
|
||||
@skipUnlessDBFeature("has_point_on_surface_method")
|
||||
def test_point_on_surface(self):
|
||||
"Testing the `point_on_surface` GeoQuerySet method."
|
||||
# Reference values.
|
||||
if oracle:
|
||||
# SELECT SDO_UTIL.TO_WKTGEOMETRY(SDO_GEOM.SDO_POINTONSURFACE(GEOAPP_COUNTRY.MPOLY, 0.05))
|
||||
# FROM GEOAPP_COUNTRY;
|
||||
ref = {'New Zealand': fromstr('POINT (174.616364 -36.100861)', srid=4326),
|
||||
'Texas': fromstr('POINT (-103.002434 36.500397)', srid=4326),
|
||||
}
|
||||
|
||||
else:
|
||||
# Using GEOSGeometry to compute the reference point on surface values
|
||||
# -- since PostGIS also uses GEOS these should be the same.
|
||||
ref = {'New Zealand': Country.objects.get(name='New Zealand').mpoly.point_on_surface,
|
||||
'Texas': Country.objects.get(name='Texas').mpoly.point_on_surface
|
||||
}
|
||||
|
||||
for c in Country.objects.point_on_surface():
|
||||
if spatialite:
|
||||
# XXX This seems to be a WKT-translation-related precision issue?
|
||||
tol = 0.00001
|
||||
else:
|
||||
tol = 0.000000001
|
||||
self.assertTrue(ref[c.name].equals_exact(c.point_on_surface, tol))
|
||||
|
||||
@skipUnlessDBFeature("has_reverse_method")
|
||||
def test_reverse_geom(self):
|
||||
"Testing GeoQuerySet.reverse_geom()."
|
||||
coords = [(-95.363151, 29.763374), (-95.448601, 29.713803)]
|
||||
Track.objects.create(name='Foo', line=LineString(coords))
|
||||
t = Track.objects.reverse_geom().get(name='Foo')
|
||||
coords.reverse()
|
||||
self.assertEqual(tuple(coords), t.reverse_geom.coords)
|
||||
if oracle:
|
||||
self.assertRaises(TypeError, State.objects.reverse_geom)
|
||||
|
||||
@skipUnlessDBFeature("has_scale_method")
|
||||
def test_scale(self):
|
||||
"Testing the `scale` GeoQuerySet method."
|
||||
xfac, yfac = 2, 3
|
||||
tol = 5 # XXX The low precision tolerance is for SpatiaLite
|
||||
qs = Country.objects.scale(xfac, yfac, model_att='scaled')
|
||||
for c in qs:
|
||||
for p1, p2 in zip(c.mpoly, c.scaled):
|
||||
for r1, r2 in zip(p1, p2):
|
||||
for c1, c2 in zip(r1.coords, r2.coords):
|
||||
self.assertAlmostEqual(c1[0] * xfac, c2[0], tol)
|
||||
self.assertAlmostEqual(c1[1] * yfac, c2[1], tol)
|
||||
|
||||
@skipUnlessDBFeature("has_snap_to_grid_method")
|
||||
def test_snap_to_grid(self):
|
||||
"Testing GeoQuerySet.snap_to_grid()."
|
||||
# Let's try and break snap_to_grid() with bad combinations of arguments.
|
||||
for bad_args in ((), range(3), range(5)):
|
||||
self.assertRaises(ValueError, Country.objects.snap_to_grid, *bad_args)
|
||||
for bad_args in (('1.0',), (1.0, None), tuple(map(six.text_type, range(4)))):
|
||||
self.assertRaises(TypeError, Country.objects.snap_to_grid, *bad_args)
|
||||
|
||||
# Boundary for San Marino, courtesy of Bjorn Sandvik of thematicmapping.org
|
||||
# from the world borders dataset he provides.
|
||||
wkt = ('MULTIPOLYGON(((12.41580 43.95795,12.45055 43.97972,12.45389 43.98167,'
|
||||
'12.46250 43.98472,12.47167 43.98694,12.49278 43.98917,'
|
||||
'12.50555 43.98861,12.51000 43.98694,12.51028 43.98277,'
|
||||
'12.51167 43.94333,12.51056 43.93916,12.49639 43.92333,'
|
||||
'12.49500 43.91472,12.48778 43.90583,12.47444 43.89722,'
|
||||
'12.46472 43.89555,12.45917 43.89611,12.41639 43.90472,'
|
||||
'12.41222 43.90610,12.40782 43.91366,12.40389 43.92667,'
|
||||
'12.40500 43.94833,12.40889 43.95499,12.41580 43.95795)))')
|
||||
Country.objects.create(name='San Marino', mpoly=fromstr(wkt))
|
||||
|
||||
# Because floating-point arithmetic isn't exact, we set a tolerance
|
||||
# to pass into GEOS `equals_exact`.
|
||||
tol = 0.000000001
|
||||
|
||||
# SELECT AsText(ST_SnapToGrid("geoapp_country"."mpoly", 0.1)) FROM "geoapp_country"
|
||||
# WHERE "geoapp_country"."name" = 'San Marino';
|
||||
ref = fromstr('MULTIPOLYGON(((12.4 44,12.5 44,12.5 43.9,12.4 43.9,12.4 44)))')
|
||||
self.assertTrue(ref.equals_exact(Country.objects.snap_to_grid(0.1).get(name='San Marino').snap_to_grid, tol))
|
||||
|
||||
# SELECT AsText(ST_SnapToGrid("geoapp_country"."mpoly", 0.05, 0.23)) FROM "geoapp_country"
|
||||
# WHERE "geoapp_country"."name" = 'San Marino';
|
||||
ref = fromstr('MULTIPOLYGON(((12.4 43.93,12.45 43.93,12.5 43.93,12.45 43.93,12.4 43.93)))')
|
||||
self.assertTrue(
|
||||
ref.equals_exact(Country.objects.snap_to_grid(0.05, 0.23).get(name='San Marino').snap_to_grid, tol)
|
||||
)
|
||||
|
||||
# SELECT AsText(ST_SnapToGrid("geoapp_country"."mpoly", 0.5, 0.17, 0.05, 0.23)) FROM "geoapp_country"
|
||||
# WHERE "geoapp_country"."name" = 'San Marino';
|
||||
ref = fromstr(
|
||||
'MULTIPOLYGON(((12.4 43.87,12.45 43.87,12.45 44.1,12.5 44.1,12.5 43.87,12.45 43.87,12.4 43.87)))'
|
||||
)
|
||||
self.assertTrue(
|
||||
ref.equals_exact(
|
||||
Country.objects.snap_to_grid(0.05, 0.23, 0.5, 0.17).get(name='San Marino').snap_to_grid,
|
||||
tol
|
||||
)
|
||||
)
|
||||
|
||||
@skipUnlessDBFeature("has_svg_method")
|
||||
def test_svg(self):
|
||||
"Testing SVG output using GeoQuerySet.svg()."
|
||||
|
||||
self.assertRaises(TypeError, City.objects.svg, precision='foo')
|
||||
# SELECT AsSVG(geoapp_city.point, 0, 8) FROM geoapp_city WHERE name = 'Pueblo';
|
||||
svg1 = 'cx="-104.609252" cy="-38.255001"'
|
||||
# Even though relative, only one point so it's practically the same except for
|
||||
# the 'c' letter prefix on the x,y values.
|
||||
svg2 = svg1.replace('c', '')
|
||||
self.assertEqual(svg1, City.objects.svg().get(name='Pueblo').svg)
|
||||
self.assertEqual(svg2, City.objects.svg(relative=5).get(name='Pueblo').svg)
|
||||
|
||||
@skipUnlessDBFeature("has_transform_method")
|
||||
def test_transform(self):
|
||||
"Testing the transform() GeoQuerySet method."
|
||||
# Pre-transformed points for Houston and Pueblo.
|
||||
htown = fromstr('POINT(1947516.83115183 6322297.06040572)', srid=3084)
|
||||
ptown = fromstr('POINT(992363.390841912 481455.395105533)', srid=2774)
|
||||
prec = 3 # Precision is low due to version variations in PROJ and GDAL.
|
||||
|
||||
# Asserting the result of the transform operation with the values in
|
||||
# the pre-transformed points. Oracle does not have the 3084 SRID.
|
||||
if not oracle:
|
||||
h = City.objects.transform(htown.srid).get(name='Houston')
|
||||
self.assertEqual(3084, h.point.srid)
|
||||
self.assertAlmostEqual(htown.x, h.point.x, prec)
|
||||
self.assertAlmostEqual(htown.y, h.point.y, prec)
|
||||
|
||||
p1 = City.objects.transform(ptown.srid, field_name='point').get(name='Pueblo')
|
||||
p2 = City.objects.transform(srid=ptown.srid).get(name='Pueblo')
|
||||
for p in [p1, p2]:
|
||||
self.assertEqual(2774, p.point.srid)
|
||||
self.assertAlmostEqual(ptown.x, p.point.x, prec)
|
||||
self.assertAlmostEqual(ptown.y, p.point.y, prec)
|
||||
|
||||
@skipUnlessDBFeature("has_translate_method")
|
||||
def test_translate(self):
|
||||
"Testing the `translate` GeoQuerySet method."
|
||||
xfac, yfac = 5, -23
|
||||
qs = Country.objects.translate(xfac, yfac, model_att='translated')
|
||||
for c in qs:
|
||||
for p1, p2 in zip(c.mpoly, c.translated):
|
||||
for r1, r2 in zip(p1, p2):
|
||||
for c1, c2 in zip(r1.coords, r2.coords):
|
||||
# XXX The low precision is for SpatiaLite
|
||||
self.assertAlmostEqual(c1[0] + xfac, c2[0], 5)
|
||||
self.assertAlmostEqual(c1[1] + yfac, c2[1], 5)
|
||||
|
||||
# TODO: Oracle can be made to pass if
|
||||
# union1 = union2 = fromstr('POINT (-97.5211570000000023 34.4646419999999978)')
|
||||
# but this seems unexpected and should be investigated to determine the cause.
|
||||
@skipUnlessDBFeature("has_unionagg_method")
|
||||
@no_oracle
|
||||
@ignore_warnings(category=RemovedInDjango20Warning)
|
||||
def test_unionagg(self):
|
||||
"""
|
||||
Testing the (deprecated) `unionagg` (aggregate union) GeoQuerySet method
|
||||
and the Union aggregate.
|
||||
"""
|
||||
tx = Country.objects.get(name='Texas').mpoly
|
||||
# Houston, Dallas -- Ordering may differ depending on backend or GEOS version.
|
||||
union1 = fromstr('MULTIPOINT(-96.801611 32.782057,-95.363151 29.763374)')
|
||||
union2 = fromstr('MULTIPOINT(-95.363151 29.763374,-96.801611 32.782057)')
|
||||
qs = City.objects.filter(point__within=tx)
|
||||
self.assertRaises(TypeError, qs.unionagg, 'name')
|
||||
self.assertRaises(ValueError, qs.aggregate, Union('name'))
|
||||
# Using `field_name` keyword argument in one query and specifying an
|
||||
# order in the other (which should not be used because this is
|
||||
# an aggregate method on a spatial column)
|
||||
u1 = qs.unionagg(field_name='point')
|
||||
u2 = qs.order_by('name').unionagg()
|
||||
u3 = qs.aggregate(Union('point'))['point__union']
|
||||
u4 = qs.order_by('name').aggregate(Union('point'))['point__union']
|
||||
tol = 0.00001
|
||||
self.assertTrue(union1.equals_exact(u1, tol) or union2.equals_exact(u1, tol))
|
||||
self.assertTrue(union1.equals_exact(u2, tol) or union2.equals_exact(u2, tol))
|
||||
self.assertTrue(union1.equals_exact(u3, tol) or union2.equals_exact(u3, tol))
|
||||
self.assertTrue(union1.equals_exact(u4, tol) or union2.equals_exact(u4, tol))
|
||||
qs = City.objects.filter(name='NotACity')
|
||||
self.assertIsNone(qs.unionagg(field_name='point'))
|
||||
self.assertIsNone(qs.aggregate(Union('point'))['point__union'])
|
||||
|
||||
def test_within_subquery(self):
|
||||
"""
|
||||
Test that using a queryset inside a geo lookup is working (using a subquery)
|
||||
(#14483).
|
||||
"""
|
||||
tex_cities = City.objects.filter(
|
||||
point__within=Country.objects.filter(name='Texas').values('mpoly')).order_by('name')
|
||||
expected = ['Dallas', 'Houston']
|
||||
if not connection.features.supports_real_shape_operations:
|
||||
expected.append('Oklahoma City')
|
||||
self.assertEqual(
|
||||
list(tex_cities.values_list('name', flat=True)),
|
||||
expected
|
||||
)
|
||||
|
||||
def test_non_concrete_field(self):
|
||||
NonConcreteModel.objects.create(point=Point(0, 0), name='name')
|
||||
list(NonConcreteModel.objects.all())
|
||||
@@ -1,26 +0,0 @@
|
||||
from __future__ import unicode_literals
|
||||
|
||||
from django.conf.urls import url
|
||||
from django.contrib.gis import views as gis_views
|
||||
from django.contrib.gis.sitemaps import views as gis_sitemap_views
|
||||
from django.contrib.sitemaps import views as sitemap_views
|
||||
|
||||
from .feeds import feed_dict
|
||||
from .sitemaps import sitemaps
|
||||
|
||||
urlpatterns = [
|
||||
url(r'^feeds/(?P<url>.*)/$', gis_views.feed, {'feed_dict': feed_dict}),
|
||||
]
|
||||
|
||||
urlpatterns += [
|
||||
url(r'^sitemaps/(?P<section>\w+)\.xml$', sitemap_views.sitemap, {'sitemaps': sitemaps}),
|
||||
]
|
||||
|
||||
urlpatterns += [
|
||||
url(r'^sitemaps/kml/(?P<label>\w+)/(?P<model>\w+)/(?P<field_name>\w+)\.kml$',
|
||||
gis_sitemap_views.kml,
|
||||
name='django.contrib.gis.sitemaps.views.kml'),
|
||||
url(r'^sitemaps/kml/(?P<label>\w+)/(?P<model>\w+)/(?P<field_name>\w+)\.kmz$',
|
||||
gis_sitemap_views.kmz,
|
||||
name='django.contrib.gis.sitemaps.views.kmz'),
|
||||
]
|
||||
@@ -1,98 +0,0 @@
|
||||
[
|
||||
{
|
||||
"pk": 1,
|
||||
"model": "geogapp.city",
|
||||
"fields": {
|
||||
"name": "Houston",
|
||||
"point": "POINT (-95.363151 29.763374)"
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 2,
|
||||
"model": "geogapp.city",
|
||||
"fields": {
|
||||
"name": "Dallas",
|
||||
"point": "POINT (-96.801611 32.782057)"
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 3,
|
||||
"model": "geogapp.city",
|
||||
"fields": {
|
||||
"name": "Oklahoma City",
|
||||
"point": "POINT (-97.521157 34.464642)"
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 4,
|
||||
"model": "geogapp.city",
|
||||
"fields": {
|
||||
"name": "Wellington",
|
||||
"point": "POINT (174.783117 -41.315268)"
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 5,
|
||||
"model": "geogapp.city",
|
||||
"fields": {
|
||||
"name": "Pueblo",
|
||||
"point": "POINT (-104.609252 38.255001)"
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 6,
|
||||
"model": "geogapp.city",
|
||||
"fields": {
|
||||
"name": "Lawrence",
|
||||
"point": "POINT (-95.235060 38.971823)"
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 7,
|
||||
"model": "geogapp.city",
|
||||
"fields": {
|
||||
"name": "Chicago",
|
||||
"point": "POINT (-87.650175 41.850385)"
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 8,
|
||||
"model": "geogapp.city",
|
||||
"fields": {
|
||||
"name": "Victoria",
|
||||
"point": "POINT (-123.305196 48.462611)"
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 1,
|
||||
"model": "geogapp.zipcode",
|
||||
"fields" : {
|
||||
"code" : "77002",
|
||||
"poly" : "SRID=4269;POLYGON ((-95.365015 29.772327, -95.362415 29.772327, -95.360915 29.771827, -95.354615 29.771827, -95.351515 29.772527, -95.350915 29.765327, -95.351015 29.762436, -95.350115 29.760328, -95.347515 29.758528, -95.352315 29.753928, -95.356415 29.756328, -95.358215 29.754028, -95.360215 29.756328, -95.363415 29.757128, -95.364014 29.75638, -95.363415 29.753928, -95.360015 29.751828, -95.361815 29.749528, -95.362715 29.750028, -95.367516 29.744128, -95.369316 29.745128, -95.373916 29.744128, -95.380116 29.738028, -95.387916 29.727929, -95.388516 29.729629, -95.387916 29.732129, -95.382916 29.737428, -95.376616 29.742228, -95.372616 29.747228, -95.378601 29.750846, -95.378616 29.752028, -95.378616 29.754428, -95.376016 29.754528, -95.374616 29.759828, -95.373616 29.761128, -95.371916 29.763928, -95.372316 29.768727, -95.365884 29.76791, -95.366015 29.767127, -95.358715 29.765327, -95.358615 29.766327, -95.359115 29.767227, -95.360215 29.767027, -95.362783 29.768267, -95.365315 29.770527, -95.365015 29.772327))"
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 2,
|
||||
"model": "geogapp.zipcode",
|
||||
"fields" : {
|
||||
"code" : "77005",
|
||||
"poly" : "SRID=4269;POLYGON ((-95.447918 29.727275, -95.428017 29.728729, -95.421117 29.729029, -95.418617 29.727629, -95.418517 29.726429, -95.402117 29.726629, -95.402117 29.725729, -95.395316 29.725729, -95.391916 29.726229, -95.389716 29.725829, -95.396517 29.715429, -95.397517 29.715929, -95.400917 29.711429, -95.411417 29.715029, -95.418417 29.714729, -95.418317 29.70623, -95.440818 29.70593, -95.445018 29.70683, -95.446618 29.70763, -95.447418 29.71003, -95.447918 29.727275))"
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 3,
|
||||
"model": "geogapp.zipcode",
|
||||
"fields" : {
|
||||
"code" : "77025",
|
||||
"poly" : "SRID=4269;POLYGON ((-95.418317 29.70623, -95.414717 29.706129, -95.414617 29.70533, -95.418217 29.70533, -95.419817 29.69533, -95.419484 29.694196, -95.417166 29.690901, -95.414517 29.69433, -95.413317 29.69263, -95.412617 29.68973, -95.412817 29.68753, -95.414087 29.685055, -95.419165 29.685428, -95.421617 29.68513, -95.425717 29.67983, -95.425017 29.67923, -95.424517 29.67763, -95.427418 29.67763, -95.438018 29.664631, -95.436713 29.664411, -95.440118 29.662231, -95.439218 29.661031, -95.437718 29.660131, -95.435718 29.659731, -95.431818 29.660331, -95.441418 29.656631, -95.441318 29.656331, -95.441818 29.656131, -95.441718 29.659031, -95.441118 29.661031, -95.446718 29.656431, -95.446518 29.673431, -95.446918 29.69013, -95.447418 29.71003, -95.446618 29.70763, -95.445018 29.70683, -95.440818 29.70593, -95.418317 29.70623))"
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 4,
|
||||
"model": "geogapp.zipcode",
|
||||
"fields" : {
|
||||
"code" : "77401",
|
||||
"poly" : "SRID=4269;POLYGON ((-95.447918 29.727275, -95.447418 29.71003, -95.446918 29.69013, -95.454318 29.68893, -95.475819 29.68903, -95.475819 29.69113, -95.484419 29.69103, -95.484519 29.69903, -95.480419 29.70133, -95.480419 29.69833, -95.474119 29.69833, -95.474119 29.70453, -95.472719 29.71283, -95.468019 29.71293, -95.468219 29.720229, -95.464018 29.720229, -95.464118 29.724529, -95.463018 29.725929, -95.459818 29.726129, -95.459918 29.720329, -95.451418 29.720429, -95.451775 29.726303, -95.451318 29.727029, -95.447918 29.727275))"
|
||||
}
|
||||
}
|
||||
]
|
||||
@@ -1,33 +0,0 @@
|
||||
from django.contrib.gis.db import models
|
||||
from django.utils.encoding import python_2_unicode_compatible
|
||||
|
||||
|
||||
@python_2_unicode_compatible
|
||||
class NamedModel(models.Model):
|
||||
name = models.CharField(max_length=30)
|
||||
|
||||
objects = models.GeoManager()
|
||||
|
||||
class Meta:
|
||||
abstract = True
|
||||
app_label = 'geogapp'
|
||||
|
||||
def __str__(self):
|
||||
return self.name
|
||||
|
||||
|
||||
class City(NamedModel):
|
||||
point = models.PointField(geography=True)
|
||||
|
||||
|
||||
class Zipcode(NamedModel):
|
||||
code = models.CharField(max_length=10)
|
||||
poly = models.PolygonField(geography=True)
|
||||
|
||||
|
||||
class County(NamedModel):
|
||||
state = models.CharField(max_length=20)
|
||||
mpoly = models.MultiPolygonField(geography=True)
|
||||
|
||||
def __str__(self):
|
||||
return ' County, '.join([self.name, self.state])
|
||||
@@ -1,102 +0,0 @@
|
||||
"""
|
||||
Tests for geography support in PostGIS
|
||||
"""
|
||||
from __future__ import unicode_literals
|
||||
|
||||
import os
|
||||
from unittest import skipUnless
|
||||
|
||||
from django.contrib.gis.gdal import HAS_GDAL
|
||||
from django.contrib.gis.geos import HAS_GEOS
|
||||
from django.contrib.gis.measure import D
|
||||
from django.contrib.gis.tests.utils import oracle, postgis
|
||||
from django.test import TestCase, skipUnlessDBFeature
|
||||
from django.utils._os import upath
|
||||
|
||||
if HAS_GEOS:
|
||||
from .models import City, County, Zipcode
|
||||
|
||||
|
||||
@skipUnlessDBFeature("gis_enabled")
|
||||
class GeographyTest(TestCase):
|
||||
fixtures = ['initial']
|
||||
|
||||
def test01_fixture_load(self):
|
||||
"Ensure geography features loaded properly."
|
||||
self.assertEqual(8, City.objects.count())
|
||||
|
||||
@skipUnlessDBFeature("supports_distances_lookups", "supports_distance_geodetic")
|
||||
def test02_distance_lookup(self):
|
||||
"Testing GeoQuerySet distance lookup support on non-point geography fields."
|
||||
z = Zipcode.objects.get(code='77002')
|
||||
cities1 = list(City.objects
|
||||
.filter(point__distance_lte=(z.poly, D(mi=500)))
|
||||
.order_by('name')
|
||||
.values_list('name', flat=True))
|
||||
cities2 = list(City.objects
|
||||
.filter(point__dwithin=(z.poly, D(mi=500)))
|
||||
.order_by('name')
|
||||
.values_list('name', flat=True))
|
||||
for cities in [cities1, cities2]:
|
||||
self.assertEqual(['Dallas', 'Houston', 'Oklahoma City'], cities)
|
||||
|
||||
@skipUnlessDBFeature("has_distance_method", "supports_distance_geodetic")
|
||||
def test03_distance_method(self):
|
||||
"Testing GeoQuerySet.distance() support on non-point geography fields."
|
||||
# `GeoQuerySet.distance` is not allowed geometry fields.
|
||||
htown = City.objects.get(name='Houston')
|
||||
Zipcode.objects.distance(htown.point)
|
||||
|
||||
@skipUnless(postgis, "This is a PostGIS-specific test")
|
||||
def test04_invalid_operators_functions(self):
|
||||
"Ensuring exceptions are raised for operators & functions invalid on geography fields."
|
||||
# Only a subset of the geometry functions & operator are available
|
||||
# to PostGIS geography types. For more information, visit:
|
||||
# http://postgis.refractions.net/documentation/manual-1.5/ch08.html#PostGIS_GeographyFunctions
|
||||
z = Zipcode.objects.get(code='77002')
|
||||
# ST_Within not available.
|
||||
self.assertRaises(ValueError, City.objects.filter(point__within=z.poly).count)
|
||||
# `@` operator not available.
|
||||
self.assertRaises(ValueError, City.objects.filter(point__contained=z.poly).count)
|
||||
|
||||
# Regression test for #14060, `~=` was never really implemented for PostGIS.
|
||||
htown = City.objects.get(name='Houston')
|
||||
self.assertRaises(ValueError, City.objects.get, point__exact=htown.point)
|
||||
|
||||
@skipUnless(HAS_GDAL, "GDAL is required.")
|
||||
def test05_geography_layermapping(self):
|
||||
"Testing LayerMapping support on models with geography fields."
|
||||
# There is a similar test in `layermap` that uses the same data set,
|
||||
# but the County model here is a bit different.
|
||||
from django.contrib.gis.utils import LayerMapping
|
||||
|
||||
# Getting the shapefile and mapping dictionary.
|
||||
shp_path = os.path.realpath(os.path.join(os.path.dirname(upath(__file__)), '..', 'data'))
|
||||
co_shp = os.path.join(shp_path, 'counties', 'counties.shp')
|
||||
co_mapping = {'name': 'Name',
|
||||
'state': 'State',
|
||||
'mpoly': 'MULTIPOLYGON',
|
||||
}
|
||||
|
||||
# Reference county names, number of polygons, and state names.
|
||||
names = ['Bexar', 'Galveston', 'Harris', 'Honolulu', 'Pueblo']
|
||||
num_polys = [1, 2, 1, 19, 1] # Number of polygons for each.
|
||||
st_names = ['Texas', 'Texas', 'Texas', 'Hawaii', 'Colorado']
|
||||
|
||||
lm = LayerMapping(County, co_shp, co_mapping, source_srs=4269, unique='name')
|
||||
lm.save(silent=True, strict=True)
|
||||
|
||||
for c, name, num_poly, state in zip(County.objects.order_by('name'), names, num_polys, st_names):
|
||||
self.assertEqual(4326, c.mpoly.srid)
|
||||
self.assertEqual(num_poly, len(c.mpoly))
|
||||
self.assertEqual(name, c.name)
|
||||
self.assertEqual(state, c.state)
|
||||
|
||||
@skipUnlessDBFeature("has_area_method", "supports_distance_geodetic")
|
||||
def test06_geography_area(self):
|
||||
"Testing that Area calculations work on geography columns."
|
||||
# SELECT ST_Area(poly) FROM geogapp_zipcode WHERE code='77002';
|
||||
ref_area = 5439100.95415646 if oracle else 5439084.70637573
|
||||
tol = 5
|
||||
z = Zipcode.objects.area().get(code='77002')
|
||||
self.assertAlmostEqual(z.area.sq_m, ref_area, tol)
|
||||
@@ -1,50 +0,0 @@
|
||||
import django.contrib.gis.db.models.fields
|
||||
from django.db import migrations, models
|
||||
|
||||
|
||||
class Migration(migrations.Migration):
|
||||
"""
|
||||
Used for gis.specific migration tests.
|
||||
"""
|
||||
operations = [
|
||||
migrations.CreateModel(
|
||||
name='Neighborhood',
|
||||
fields=[
|
||||
('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
|
||||
('name', models.CharField(max_length=100, unique=True)),
|
||||
('geom', django.contrib.gis.db.models.fields.MultiPolygonField(srid=4326)),
|
||||
],
|
||||
options={
|
||||
},
|
||||
bases=(models.Model,),
|
||||
),
|
||||
migrations.CreateModel(
|
||||
name='Household',
|
||||
fields=[
|
||||
('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
|
||||
('neighborhood', models.ForeignKey(to='gis_migrations.Neighborhood', to_field='id', null=True)),
|
||||
('address', models.CharField(max_length=100)),
|
||||
('zip_code', models.IntegerField(null=True, blank=True)),
|
||||
('geom', django.contrib.gis.db.models.fields.PointField(srid=4326, geography=True)),
|
||||
],
|
||||
options={
|
||||
},
|
||||
bases=(models.Model,),
|
||||
),
|
||||
migrations.CreateModel(
|
||||
name='Family',
|
||||
fields=[
|
||||
('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
|
||||
('name', models.CharField(max_length=100, unique=True)),
|
||||
],
|
||||
options={
|
||||
},
|
||||
bases=(models.Model,),
|
||||
),
|
||||
migrations.AddField(
|
||||
model_name='household',
|
||||
name='family',
|
||||
field=models.ForeignKey(blank=True, to='gis_migrations.Family', null=True),
|
||||
preserve_default=True,
|
||||
),
|
||||
]
|
||||
@@ -1,61 +0,0 @@
|
||||
from __future__ import unicode_literals
|
||||
|
||||
from django.core.management import call_command
|
||||
from django.db import connection
|
||||
from django.test import TransactionTestCase, skipUnlessDBFeature
|
||||
|
||||
|
||||
@skipUnlessDBFeature("gis_enabled")
|
||||
class MigrateTests(TransactionTestCase):
|
||||
"""
|
||||
Tests running the migrate command in Geodjango.
|
||||
"""
|
||||
available_apps = ["django.contrib.gis.tests.gis_migrations"]
|
||||
|
||||
def get_table_description(self, table):
|
||||
with connection.cursor() as cursor:
|
||||
return connection.introspection.get_table_description(cursor, table)
|
||||
|
||||
def assertTableExists(self, table):
|
||||
with connection.cursor() as cursor:
|
||||
self.assertIn(table, connection.introspection.table_names(cursor))
|
||||
|
||||
def assertTableNotExists(self, table):
|
||||
with connection.cursor() as cursor:
|
||||
self.assertNotIn(table, connection.introspection.table_names(cursor))
|
||||
|
||||
def test_migrate_gis(self):
|
||||
"""
|
||||
Tests basic usage of the migrate command when a model uses Geodjango
|
||||
fields. Regression test for ticket #22001:
|
||||
https://code.djangoproject.com/ticket/22001
|
||||
|
||||
It's also used to showcase an error in migrations where spatialite is
|
||||
enabled and geo tables are renamed resulting in unique constraint
|
||||
failure on geometry_columns. Regression for ticket #23030:
|
||||
https://code.djangoproject.com/ticket/23030
|
||||
"""
|
||||
# Make sure the right tables exist
|
||||
self.assertTableExists("gis_migrations_neighborhood")
|
||||
self.assertTableExists("gis_migrations_household")
|
||||
self.assertTableExists("gis_migrations_family")
|
||||
# Unmigrate everything
|
||||
call_command("migrate", "gis_migrations", "zero", verbosity=0)
|
||||
# Make sure it's all gone
|
||||
self.assertTableNotExists("gis_migrations_neighborhood")
|
||||
self.assertTableNotExists("gis_migrations_household")
|
||||
self.assertTableNotExists("gis_migrations_family")
|
||||
# Even geometry columns metadata
|
||||
try:
|
||||
GeoColumn = connection.ops.geometry_columns()
|
||||
except NotImplementedError:
|
||||
# Not all GIS backends have geometry columns model
|
||||
pass
|
||||
else:
|
||||
self.assertEqual(
|
||||
GeoColumn.objects.filter(
|
||||
**{'%s__in' % GeoColumn.table_name_col(): ["gis_neighborhood", "gis_household"]}
|
||||
).count(),
|
||||
0)
|
||||
# Revert the "unmigration"
|
||||
call_command("migrate", "gis_migrations", verbosity=0)
|
||||
@@ -1,152 +0,0 @@
|
||||
from __future__ import unicode_literals
|
||||
|
||||
from django.contrib.gis.tests.utils import mysql
|
||||
from django.db import connection, migrations, models
|
||||
from django.db.migrations.migration import Migration
|
||||
from django.db.migrations.state import ProjectState
|
||||
from django.test import TransactionTestCase, skipUnlessDBFeature
|
||||
|
||||
if connection.features.gis_enabled:
|
||||
from django.contrib.gis.db.models import fields
|
||||
try:
|
||||
GeometryColumns = connection.ops.geometry_columns()
|
||||
HAS_GEOMETRY_COLUMNS = True
|
||||
except NotImplementedError:
|
||||
HAS_GEOMETRY_COLUMNS = False
|
||||
|
||||
|
||||
@skipUnlessDBFeature("gis_enabled")
|
||||
class OperationTests(TransactionTestCase):
|
||||
available_apps = ["django.contrib.gis.tests.gis_migrations"]
|
||||
|
||||
def tearDown(self):
|
||||
# Delete table after testing
|
||||
self.apply_operations('gis', self.current_state, [migrations.DeleteModel("Neighborhood")])
|
||||
super(OperationTests, self).tearDown()
|
||||
|
||||
def get_table_description(self, table):
|
||||
with connection.cursor() as cursor:
|
||||
return connection.introspection.get_table_description(cursor, table)
|
||||
|
||||
def assertColumnExists(self, table, column):
|
||||
self.assertIn(column, [c.name for c in self.get_table_description(table)])
|
||||
|
||||
def assertColumnNotExists(self, table, column):
|
||||
self.assertNotIn(column, [c.name for c in self.get_table_description(table)])
|
||||
|
||||
def apply_operations(self, app_label, project_state, operations):
|
||||
migration = Migration('name', app_label)
|
||||
migration.operations = operations
|
||||
with connection.schema_editor() as editor:
|
||||
return migration.apply(project_state, editor)
|
||||
|
||||
def set_up_test_model(self):
|
||||
operations = [migrations.CreateModel(
|
||||
"Neighborhood",
|
||||
[
|
||||
("id", models.AutoField(primary_key=True)),
|
||||
('name', models.CharField(max_length=100, unique=True)),
|
||||
('geom', fields.MultiPolygonField(srid=4326)),
|
||||
],
|
||||
)]
|
||||
return self.apply_operations('gis', ProjectState(), operations)
|
||||
|
||||
def assertGeometryColumnsCount(self, expected_count):
|
||||
table_name = "gis_neighborhood"
|
||||
if connection.features.uppercases_column_names:
|
||||
table_name = table_name.upper()
|
||||
self.assertEqual(
|
||||
GeometryColumns.objects.filter(**{
|
||||
GeometryColumns.table_name_col(): table_name,
|
||||
}).count(),
|
||||
expected_count
|
||||
)
|
||||
|
||||
def test_add_gis_field(self):
|
||||
"""
|
||||
Tests the AddField operation with a GIS-enabled column.
|
||||
"""
|
||||
project_state = self.set_up_test_model()
|
||||
self.current_state = project_state
|
||||
operation = migrations.AddField(
|
||||
"Neighborhood",
|
||||
"path",
|
||||
fields.LineStringField(srid=4326),
|
||||
)
|
||||
new_state = project_state.clone()
|
||||
operation.state_forwards("gis", new_state)
|
||||
with connection.schema_editor() as editor:
|
||||
operation.database_forwards("gis", editor, project_state, new_state)
|
||||
self.current_state = new_state
|
||||
self.assertColumnExists("gis_neighborhood", "path")
|
||||
|
||||
# Test GeometryColumns when available
|
||||
if HAS_GEOMETRY_COLUMNS:
|
||||
self.assertGeometryColumnsCount(2)
|
||||
|
||||
if self.has_spatial_indexes:
|
||||
with connection.cursor() as cursor:
|
||||
indexes = connection.introspection.get_indexes(cursor, "gis_neighborhood")
|
||||
self.assertIn('path', indexes)
|
||||
|
||||
def test_add_blank_gis_field(self):
|
||||
"""
|
||||
Should be able to add a GeometryField with blank=True.
|
||||
"""
|
||||
project_state = self.set_up_test_model()
|
||||
self.current_state = project_state
|
||||
operation = migrations.AddField(
|
||||
"Neighborhood",
|
||||
"path",
|
||||
fields.LineStringField(blank=True, srid=4326),
|
||||
)
|
||||
new_state = project_state.clone()
|
||||
operation.state_forwards("gis", new_state)
|
||||
with connection.schema_editor() as editor:
|
||||
operation.database_forwards("gis", editor, project_state, new_state)
|
||||
self.current_state = new_state
|
||||
self.assertColumnExists("gis_neighborhood", "path")
|
||||
|
||||
# Test GeometryColumns when available
|
||||
if HAS_GEOMETRY_COLUMNS:
|
||||
self.assertGeometryColumnsCount(2)
|
||||
|
||||
if self.has_spatial_indexes:
|
||||
with connection.cursor() as cursor:
|
||||
indexes = connection.introspection.get_indexes(cursor, "gis_neighborhood")
|
||||
self.assertIn('path', indexes)
|
||||
|
||||
def test_remove_gis_field(self):
|
||||
"""
|
||||
Tests the RemoveField operation with a GIS-enabled column.
|
||||
"""
|
||||
project_state = self.set_up_test_model()
|
||||
self.current_state = project_state
|
||||
operation = migrations.RemoveField("Neighborhood", "geom")
|
||||
new_state = project_state.clone()
|
||||
operation.state_forwards("gis", new_state)
|
||||
with connection.schema_editor() as editor:
|
||||
operation.database_forwards("gis", editor, project_state, new_state)
|
||||
self.current_state = new_state
|
||||
self.assertColumnNotExists("gis_neighborhood", "geom")
|
||||
|
||||
# Test GeometryColumns when available
|
||||
if HAS_GEOMETRY_COLUMNS:
|
||||
self.assertGeometryColumnsCount(0)
|
||||
|
||||
def test_create_model_spatial_index(self):
|
||||
self.current_state = self.set_up_test_model()
|
||||
|
||||
if not self.has_spatial_indexes:
|
||||
self.skipTest("No support for Spatial indexes")
|
||||
|
||||
with connection.cursor() as cursor:
|
||||
indexes = connection.introspection.get_indexes(cursor, "gis_neighborhood")
|
||||
self.assertIn('geom', indexes)
|
||||
|
||||
@property
|
||||
def has_spatial_indexes(self):
|
||||
if mysql:
|
||||
with connection.cursor() as cursor:
|
||||
return connection.introspection.supports_spatial_index(cursor, "gis_neighborhood")
|
||||
return True
|
||||
@@ -1,19 +0,0 @@
|
||||
from django.contrib.gis.db import models
|
||||
|
||||
|
||||
class AllOGRFields(models.Model):
|
||||
|
||||
f_decimal = models.FloatField()
|
||||
f_float = models.FloatField()
|
||||
f_int = models.IntegerField()
|
||||
f_char = models.CharField(max_length=10)
|
||||
f_date = models.DateField()
|
||||
f_datetime = models.DateTimeField()
|
||||
f_time = models.TimeField()
|
||||
geom = models.PolygonField()
|
||||
point = models.PointField()
|
||||
|
||||
objects = models.GeoManager()
|
||||
|
||||
class Meta:
|
||||
app_label = 'inspectapp'
|
||||
@@ -1,175 +0,0 @@
|
||||
from __future__ import unicode_literals
|
||||
|
||||
import os
|
||||
import re
|
||||
from unittest import skipUnless
|
||||
|
||||
from django.contrib.gis.gdal import HAS_GDAL
|
||||
from django.contrib.gis.geometry.test_data import TEST_DATA
|
||||
from django.core.management import call_command
|
||||
from django.db import connection, connections
|
||||
from django.test import TestCase, skipUnlessDBFeature
|
||||
from django.utils.six import StringIO
|
||||
|
||||
if HAS_GDAL:
|
||||
from django.contrib.gis.gdal import Driver, GDALException
|
||||
from django.contrib.gis.utils.ogrinspect import ogrinspect
|
||||
|
||||
from .models import AllOGRFields
|
||||
|
||||
|
||||
@skipUnless(HAS_GDAL, "InspectDbTests needs GDAL support")
|
||||
@skipUnlessDBFeature("gis_enabled")
|
||||
class InspectDbTests(TestCase):
|
||||
def test_geom_columns(self):
|
||||
"""
|
||||
Test the geo-enabled inspectdb command.
|
||||
"""
|
||||
out = StringIO()
|
||||
call_command('inspectdb',
|
||||
table_name_filter=lambda tn: tn.startswith('inspectapp_'),
|
||||
stdout=out)
|
||||
output = out.getvalue()
|
||||
if connection.features.supports_geometry_field_introspection:
|
||||
self.assertIn('geom = models.PolygonField()', output)
|
||||
self.assertIn('point = models.PointField()', output)
|
||||
else:
|
||||
self.assertIn('geom = models.GeometryField(', output)
|
||||
self.assertIn('point = models.GeometryField(', output)
|
||||
self.assertIn('objects = models.GeoManager()', output)
|
||||
|
||||
|
||||
@skipUnless(HAS_GDAL, "OGRInspectTest needs GDAL support")
|
||||
@skipUnlessDBFeature("gis_enabled")
|
||||
class OGRInspectTest(TestCase):
|
||||
maxDiff = 1024
|
||||
|
||||
def test_poly(self):
|
||||
shp_file = os.path.join(TEST_DATA, 'test_poly', 'test_poly.shp')
|
||||
model_def = ogrinspect(shp_file, 'MyModel')
|
||||
|
||||
expected = [
|
||||
'# This is an auto-generated Django model module created by ogrinspect.',
|
||||
'from django.contrib.gis.db import models',
|
||||
'',
|
||||
'class MyModel(models.Model):',
|
||||
' float = models.FloatField()',
|
||||
' int = models.FloatField()',
|
||||
' str = models.CharField(max_length=80)',
|
||||
' geom = models.PolygonField(srid=-1)',
|
||||
' objects = models.GeoManager()',
|
||||
]
|
||||
|
||||
self.assertEqual(model_def, '\n'.join(expected))
|
||||
|
||||
def test_date_field(self):
|
||||
shp_file = os.path.join(TEST_DATA, 'cities', 'cities.shp')
|
||||
model_def = ogrinspect(shp_file, 'City')
|
||||
|
||||
expected = [
|
||||
'# This is an auto-generated Django model module created by ogrinspect.',
|
||||
'from django.contrib.gis.db import models',
|
||||
'',
|
||||
'class City(models.Model):',
|
||||
' name = models.CharField(max_length=80)',
|
||||
' population = models.FloatField()',
|
||||
' density = models.FloatField()',
|
||||
' created = models.DateField()',
|
||||
' geom = models.PointField(srid=-1)',
|
||||
' objects = models.GeoManager()',
|
||||
]
|
||||
|
||||
self.assertEqual(model_def, '\n'.join(expected))
|
||||
|
||||
def test_time_field(self):
|
||||
# Getting the database identifier used by OGR, if None returned
|
||||
# GDAL does not have the support compiled in.
|
||||
ogr_db = get_ogr_db_string()
|
||||
if not ogr_db:
|
||||
self.skipTest("Unable to setup an OGR connection to your database")
|
||||
|
||||
try:
|
||||
# Writing shapefiles via GDAL currently does not support writing OGRTime
|
||||
# fields, so we need to actually use a database
|
||||
model_def = ogrinspect(ogr_db, 'Measurement',
|
||||
layer_key=AllOGRFields._meta.db_table,
|
||||
decimal=['f_decimal'])
|
||||
except GDALException:
|
||||
self.skipTest("Unable to setup an OGR connection to your database")
|
||||
|
||||
self.assertTrue(model_def.startswith(
|
||||
'# This is an auto-generated Django model module created by ogrinspect.\n'
|
||||
'from django.contrib.gis.db import models\n'
|
||||
'\n'
|
||||
'class Measurement(models.Model):\n'
|
||||
))
|
||||
|
||||
# The ordering of model fields might vary depending on several factors (version of GDAL, etc.)
|
||||
self.assertIn(' f_decimal = models.DecimalField(max_digits=0, decimal_places=0)', model_def)
|
||||
self.assertIn(' f_int = models.IntegerField()', model_def)
|
||||
self.assertIn(' f_datetime = models.DateTimeField()', model_def)
|
||||
self.assertIn(' f_time = models.TimeField()', model_def)
|
||||
self.assertIn(' f_float = models.FloatField()', model_def)
|
||||
self.assertIn(' f_char = models.CharField(max_length=10)', model_def)
|
||||
self.assertIn(' f_date = models.DateField()', model_def)
|
||||
|
||||
self.assertIsNotNone(re.search(
|
||||
r' geom = models.PolygonField\(([^\)])*\)\n' # Some backends may have srid=-1
|
||||
r' objects = models.GeoManager\(\)', model_def))
|
||||
|
||||
def test_management_command(self):
|
||||
shp_file = os.path.join(TEST_DATA, 'cities', 'cities.shp')
|
||||
out = StringIO()
|
||||
call_command('ogrinspect', shp_file, 'City', stdout=out)
|
||||
output = out.getvalue()
|
||||
self.assertIn('class City(models.Model):', output)
|
||||
|
||||
|
||||
def get_ogr_db_string():
|
||||
"""
|
||||
Construct the DB string that GDAL will use to inspect the database.
|
||||
GDAL will create its own connection to the database, so we re-use the
|
||||
connection settings from the Django test.
|
||||
"""
|
||||
db = connections.databases['default']
|
||||
|
||||
# Map from the django backend into the OGR driver name and database identifier
|
||||
# http://www.gdal.org/ogr/ogr_formats.html
|
||||
#
|
||||
# TODO: Support Oracle (OCI).
|
||||
drivers = {
|
||||
'django.contrib.gis.db.backends.postgis': ('PostgreSQL', "PG:dbname='%(db_name)s'", ' '),
|
||||
'django.contrib.gis.db.backends.mysql': ('MySQL', 'MYSQL:"%(db_name)s"', ','),
|
||||
'django.contrib.gis.db.backends.spatialite': ('SQLite', '%(db_name)s', '')
|
||||
}
|
||||
|
||||
db_engine = db['ENGINE']
|
||||
if db_engine not in drivers:
|
||||
return None
|
||||
|
||||
drv_name, db_str, param_sep = drivers[db_engine]
|
||||
|
||||
# Ensure that GDAL library has driver support for the database.
|
||||
try:
|
||||
Driver(drv_name)
|
||||
except:
|
||||
return None
|
||||
|
||||
# SQLite/Spatialite in-memory databases
|
||||
if db['NAME'] == ":memory:":
|
||||
return None
|
||||
|
||||
# Build the params of the OGR database connection string
|
||||
params = [db_str % {'db_name': db['NAME']}]
|
||||
|
||||
def add(key, template):
|
||||
value = db.get(key, None)
|
||||
# Don't add the parameter if it is not in django's settings
|
||||
if value:
|
||||
params.append(template % value)
|
||||
add('HOST', "host='%s'")
|
||||
add('PORT', "port='%s'")
|
||||
add('USER', "user='%s'")
|
||||
add('PASSWORD', "password='%s'")
|
||||
|
||||
return param_sep.join(params)
|
||||
@@ -1,96 +0,0 @@
|
||||
from django.contrib.gis.db import models
|
||||
from django.utils.encoding import python_2_unicode_compatible
|
||||
|
||||
|
||||
@python_2_unicode_compatible
|
||||
class NamedModel(models.Model):
|
||||
name = models.CharField(max_length=25)
|
||||
|
||||
objects = models.GeoManager()
|
||||
|
||||
class Meta:
|
||||
abstract = True
|
||||
app_label = 'layermap'
|
||||
|
||||
def __str__(self):
|
||||
return self.name
|
||||
|
||||
|
||||
class State(NamedModel):
|
||||
pass
|
||||
|
||||
|
||||
class County(NamedModel):
|
||||
state = models.ForeignKey(State)
|
||||
mpoly = models.MultiPolygonField(srid=4269) # Multipolygon in NAD83
|
||||
|
||||
|
||||
class CountyFeat(NamedModel):
|
||||
poly = models.PolygonField(srid=4269)
|
||||
|
||||
|
||||
class City(NamedModel):
|
||||
name_txt = models.TextField(default='')
|
||||
name_short = models.CharField(max_length=5)
|
||||
population = models.IntegerField()
|
||||
density = models.DecimalField(max_digits=7, decimal_places=1)
|
||||
dt = models.DateField()
|
||||
point = models.PointField()
|
||||
|
||||
|
||||
class Interstate(NamedModel):
|
||||
length = models.DecimalField(max_digits=6, decimal_places=2)
|
||||
path = models.LineStringField()
|
||||
|
||||
|
||||
# Same as `City` above, but for testing model inheritance.
|
||||
class CityBase(NamedModel):
|
||||
population = models.IntegerField()
|
||||
density = models.DecimalField(max_digits=7, decimal_places=1)
|
||||
point = models.PointField()
|
||||
|
||||
|
||||
class ICity1(CityBase):
|
||||
dt = models.DateField()
|
||||
|
||||
class Meta(CityBase.Meta):
|
||||
pass
|
||||
|
||||
|
||||
class ICity2(ICity1):
|
||||
dt_time = models.DateTimeField(auto_now=True)
|
||||
|
||||
class Meta(ICity1.Meta):
|
||||
pass
|
||||
|
||||
|
||||
class Invalid(models.Model):
|
||||
point = models.PointField()
|
||||
|
||||
class Meta:
|
||||
app_label = 'layermap'
|
||||
|
||||
|
||||
# Mapping dictionaries for the models above.
|
||||
co_mapping = {
|
||||
'name': 'Name',
|
||||
# ForeignKey's use another mapping dictionary for the _related_ Model (State in this case).
|
||||
'state': {'name': 'State'},
|
||||
'mpoly': 'MULTIPOLYGON', # Will convert POLYGON features into MULTIPOLYGONS.
|
||||
}
|
||||
|
||||
cofeat_mapping = {'name': 'Name',
|
||||
'poly': 'POLYGON',
|
||||
}
|
||||
|
||||
city_mapping = {'name': 'Name',
|
||||
'population': 'Population',
|
||||
'density': 'Density',
|
||||
'dt': 'Created',
|
||||
'point': 'POINT',
|
||||
}
|
||||
|
||||
inter_mapping = {'name': 'Name',
|
||||
'length': 'Length',
|
||||
'path': 'LINESTRING',
|
||||
}
|
||||
@@ -1,337 +0,0 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
from __future__ import unicode_literals
|
||||
|
||||
import os
|
||||
import unittest
|
||||
from copy import copy
|
||||
from decimal import Decimal
|
||||
from unittest import skipUnless
|
||||
|
||||
from django.conf import settings
|
||||
from django.contrib.gis.gdal import HAS_GDAL
|
||||
from django.db import connection
|
||||
from django.test import TestCase, override_settings, skipUnlessDBFeature
|
||||
from django.utils._os import upath
|
||||
|
||||
if HAS_GDAL:
|
||||
from django.contrib.gis.utils.layermapping import (LayerMapping,
|
||||
LayerMapError, InvalidDecimal, InvalidString, MissingForeignKey)
|
||||
from django.contrib.gis.gdal import DataSource
|
||||
|
||||
from .models import (
|
||||
City, County, CountyFeat, Interstate, ICity1, ICity2, Invalid, State,
|
||||
city_mapping, co_mapping, cofeat_mapping, inter_mapping)
|
||||
|
||||
|
||||
shp_path = os.path.realpath(os.path.join(os.path.dirname(upath(__file__)), os.pardir, 'data'))
|
||||
city_shp = os.path.join(shp_path, 'cities', 'cities.shp')
|
||||
co_shp = os.path.join(shp_path, 'counties', 'counties.shp')
|
||||
inter_shp = os.path.join(shp_path, 'interstates', 'interstates.shp')
|
||||
invalid_shp = os.path.join(shp_path, 'invalid', 'emptypoints.shp')
|
||||
|
||||
# Dictionaries to hold what's expected in the county shapefile.
|
||||
NAMES = ['Bexar', 'Galveston', 'Harris', 'Honolulu', 'Pueblo']
|
||||
NUMS = [1, 2, 1, 19, 1] # Number of polygons for each.
|
||||
STATES = ['Texas', 'Texas', 'Texas', 'Hawaii', 'Colorado']
|
||||
|
||||
|
||||
@skipUnless(HAS_GDAL, "LayerMapTest needs GDAL support")
|
||||
@skipUnlessDBFeature("gis_enabled")
|
||||
class LayerMapTest(TestCase):
|
||||
|
||||
def test_init(self):
|
||||
"Testing LayerMapping initialization."
|
||||
|
||||
# Model field that does not exist.
|
||||
bad1 = copy(city_mapping)
|
||||
bad1['foobar'] = 'FooField'
|
||||
|
||||
# Shapefile field that does not exist.
|
||||
bad2 = copy(city_mapping)
|
||||
bad2['name'] = 'Nombre'
|
||||
|
||||
# Nonexistent geographic field type.
|
||||
bad3 = copy(city_mapping)
|
||||
bad3['point'] = 'CURVE'
|
||||
|
||||
# Incrementing through the bad mapping dictionaries and
|
||||
# ensuring that a LayerMapError is raised.
|
||||
for bad_map in (bad1, bad2, bad3):
|
||||
with self.assertRaises(LayerMapError):
|
||||
LayerMapping(City, city_shp, bad_map)
|
||||
|
||||
# A LookupError should be thrown for bogus encodings.
|
||||
with self.assertRaises(LookupError):
|
||||
LayerMapping(City, city_shp, city_mapping, encoding='foobar')
|
||||
|
||||
def test_simple_layermap(self):
|
||||
"Test LayerMapping import of a simple point shapefile."
|
||||
# Setting up for the LayerMapping.
|
||||
lm = LayerMapping(City, city_shp, city_mapping)
|
||||
lm.save()
|
||||
|
||||
# There should be three cities in the shape file.
|
||||
self.assertEqual(3, City.objects.count())
|
||||
|
||||
# Opening up the shapefile, and verifying the values in each
|
||||
# of the features made it to the model.
|
||||
ds = DataSource(city_shp)
|
||||
layer = ds[0]
|
||||
for feat in layer:
|
||||
city = City.objects.get(name=feat['Name'].value)
|
||||
self.assertEqual(feat['Population'].value, city.population)
|
||||
self.assertEqual(Decimal(str(feat['Density'])), city.density)
|
||||
self.assertEqual(feat['Created'].value, city.dt)
|
||||
|
||||
# Comparing the geometries.
|
||||
pnt1, pnt2 = feat.geom, city.point
|
||||
self.assertAlmostEqual(pnt1.x, pnt2.x, 5)
|
||||
self.assertAlmostEqual(pnt1.y, pnt2.y, 5)
|
||||
|
||||
def test_layermap_strict(self):
|
||||
"Testing the `strict` keyword, and import of a LineString shapefile."
|
||||
# When the `strict` keyword is set an error encountered will force
|
||||
# the importation to stop.
|
||||
with self.assertRaises(InvalidDecimal):
|
||||
lm = LayerMapping(Interstate, inter_shp, inter_mapping)
|
||||
lm.save(silent=True, strict=True)
|
||||
Interstate.objects.all().delete()
|
||||
|
||||
# This LayerMapping should work b/c `strict` is not set.
|
||||
lm = LayerMapping(Interstate, inter_shp, inter_mapping)
|
||||
lm.save(silent=True)
|
||||
|
||||
# Two interstate should have imported correctly.
|
||||
self.assertEqual(2, Interstate.objects.count())
|
||||
|
||||
# Verifying the values in the layer w/the model.
|
||||
ds = DataSource(inter_shp)
|
||||
|
||||
# Only the first two features of this shapefile are valid.
|
||||
valid_feats = ds[0][:2]
|
||||
for feat in valid_feats:
|
||||
istate = Interstate.objects.get(name=feat['Name'].value)
|
||||
|
||||
if feat.fid == 0:
|
||||
self.assertEqual(Decimal(str(feat['Length'])), istate.length)
|
||||
elif feat.fid == 1:
|
||||
# Everything but the first two decimal digits were truncated,
|
||||
# because the Interstate model's `length` field has decimal_places=2.
|
||||
self.assertAlmostEqual(feat.get('Length'), float(istate.length), 2)
|
||||
|
||||
for p1, p2 in zip(feat.geom, istate.path):
|
||||
self.assertAlmostEqual(p1[0], p2[0], 6)
|
||||
self.assertAlmostEqual(p1[1], p2[1], 6)
|
||||
|
||||
def county_helper(self, county_feat=True):
|
||||
"Helper function for ensuring the integrity of the mapped County models."
|
||||
for name, n, st in zip(NAMES, NUMS, STATES):
|
||||
# Should only be one record b/c of `unique` keyword.
|
||||
c = County.objects.get(name=name)
|
||||
self.assertEqual(n, len(c.mpoly))
|
||||
self.assertEqual(st, c.state.name) # Checking ForeignKey mapping.
|
||||
|
||||
# Multiple records because `unique` was not set.
|
||||
if county_feat:
|
||||
qs = CountyFeat.objects.filter(name=name)
|
||||
self.assertEqual(n, qs.count())
|
||||
|
||||
def test_layermap_unique_multigeometry_fk(self):
|
||||
"Testing the `unique`, and `transform`, geometry collection conversion, and ForeignKey mappings."
|
||||
# All the following should work.
|
||||
try:
|
||||
# Telling LayerMapping that we want no transformations performed on the data.
|
||||
lm = LayerMapping(County, co_shp, co_mapping, transform=False)
|
||||
|
||||
# Specifying the source spatial reference system via the `source_srs` keyword.
|
||||
lm = LayerMapping(County, co_shp, co_mapping, source_srs=4269)
|
||||
lm = LayerMapping(County, co_shp, co_mapping, source_srs='NAD83')
|
||||
|
||||
# Unique may take tuple or string parameters.
|
||||
for arg in ('name', ('name', 'mpoly')):
|
||||
lm = LayerMapping(County, co_shp, co_mapping, transform=False, unique=arg)
|
||||
except Exception:
|
||||
self.fail('No exception should be raised for proper use of keywords.')
|
||||
|
||||
# Testing invalid params for the `unique` keyword.
|
||||
for e, arg in ((TypeError, 5.0), (ValueError, 'foobar'), (ValueError, ('name', 'mpolygon'))):
|
||||
self.assertRaises(e, LayerMapping, County, co_shp, co_mapping, transform=False, unique=arg)
|
||||
|
||||
# No source reference system defined in the shapefile, should raise an error.
|
||||
if connection.features.supports_transform:
|
||||
self.assertRaises(LayerMapError, LayerMapping, County, co_shp, co_mapping)
|
||||
|
||||
# Passing in invalid ForeignKey mapping parameters -- must be a dictionary
|
||||
# mapping for the model the ForeignKey points to.
|
||||
bad_fk_map1 = copy(co_mapping)
|
||||
bad_fk_map1['state'] = 'name'
|
||||
bad_fk_map2 = copy(co_mapping)
|
||||
bad_fk_map2['state'] = {'nombre': 'State'}
|
||||
self.assertRaises(TypeError, LayerMapping, County, co_shp, bad_fk_map1, transform=False)
|
||||
self.assertRaises(LayerMapError, LayerMapping, County, co_shp, bad_fk_map2, transform=False)
|
||||
|
||||
# There exist no State models for the ForeignKey mapping to work -- should raise
|
||||
# a MissingForeignKey exception (this error would be ignored if the `strict`
|
||||
# keyword is not set).
|
||||
lm = LayerMapping(County, co_shp, co_mapping, transform=False, unique='name')
|
||||
self.assertRaises(MissingForeignKey, lm.save, silent=True, strict=True)
|
||||
|
||||
# Now creating the state models so the ForeignKey mapping may work.
|
||||
State.objects.bulk_create([
|
||||
State(name='Colorado'), State(name='Hawaii'), State(name='Texas')
|
||||
])
|
||||
|
||||
# If a mapping is specified as a collection, all OGR fields that
|
||||
# are not collections will be converted into them. For example,
|
||||
# a Point column would be converted to MultiPoint. Other things being done
|
||||
# w/the keyword args:
|
||||
# `transform=False`: Specifies that no transform is to be done; this
|
||||
# has the effect of ignoring the spatial reference check (because the
|
||||
# county shapefile does not have implicit spatial reference info).
|
||||
#
|
||||
# `unique='name'`: Creates models on the condition that they have
|
||||
# unique county names; geometries from each feature however will be
|
||||
# appended to the geometry collection of the unique model. Thus,
|
||||
# all of the various islands in Honolulu county will be in in one
|
||||
# database record with a MULTIPOLYGON type.
|
||||
lm = LayerMapping(County, co_shp, co_mapping, transform=False, unique='name')
|
||||
lm.save(silent=True, strict=True)
|
||||
|
||||
# A reference that doesn't use the unique keyword; a new database record will
|
||||
# created for each polygon.
|
||||
lm = LayerMapping(CountyFeat, co_shp, cofeat_mapping, transform=False)
|
||||
lm.save(silent=True, strict=True)
|
||||
|
||||
# The county helper is called to ensure integrity of County models.
|
||||
self.county_helper()
|
||||
|
||||
def test_test_fid_range_step(self):
|
||||
"Tests the `fid_range` keyword and the `step` keyword of .save()."
|
||||
# Function for clearing out all the counties before testing.
|
||||
def clear_counties():
|
||||
County.objects.all().delete()
|
||||
|
||||
State.objects.bulk_create([
|
||||
State(name='Colorado'), State(name='Hawaii'), State(name='Texas')
|
||||
])
|
||||
|
||||
# Initializing the LayerMapping object to use in these tests.
|
||||
lm = LayerMapping(County, co_shp, co_mapping, transform=False, unique='name')
|
||||
|
||||
# Bad feature id ranges should raise a type error.
|
||||
bad_ranges = (5.0, 'foo', co_shp)
|
||||
for bad in bad_ranges:
|
||||
self.assertRaises(TypeError, lm.save, fid_range=bad)
|
||||
|
||||
# Step keyword should not be allowed w/`fid_range`.
|
||||
fr = (3, 5) # layer[3:5]
|
||||
self.assertRaises(LayerMapError, lm.save, fid_range=fr, step=10)
|
||||
lm.save(fid_range=fr)
|
||||
|
||||
# Features IDs 3 & 4 are for Galveston County, Texas -- only
|
||||
# one model is returned because the `unique` keyword was set.
|
||||
qs = County.objects.all()
|
||||
self.assertEqual(1, qs.count())
|
||||
self.assertEqual('Galveston', qs[0].name)
|
||||
|
||||
# Features IDs 5 and beyond for Honolulu County, Hawaii, and
|
||||
# FID 0 is for Pueblo County, Colorado.
|
||||
clear_counties()
|
||||
lm.save(fid_range=slice(5, None), silent=True, strict=True) # layer[5:]
|
||||
lm.save(fid_range=slice(None, 1), silent=True, strict=True) # layer[:1]
|
||||
|
||||
# Only Pueblo & Honolulu counties should be present because of
|
||||
# the `unique` keyword. Have to set `order_by` on this QuerySet
|
||||
# or else MySQL will return a different ordering than the other dbs.
|
||||
qs = County.objects.order_by('name')
|
||||
self.assertEqual(2, qs.count())
|
||||
hi, co = tuple(qs)
|
||||
hi_idx, co_idx = tuple(map(NAMES.index, ('Honolulu', 'Pueblo')))
|
||||
self.assertEqual('Pueblo', co.name)
|
||||
self.assertEqual(NUMS[co_idx], len(co.mpoly))
|
||||
self.assertEqual('Honolulu', hi.name)
|
||||
self.assertEqual(NUMS[hi_idx], len(hi.mpoly))
|
||||
|
||||
# Testing the `step` keyword -- should get the same counties
|
||||
# regardless of we use a step that divides equally, that is odd,
|
||||
# or that is larger than the dataset.
|
||||
for st in (4, 7, 1000):
|
||||
clear_counties()
|
||||
lm.save(step=st, strict=True)
|
||||
self.county_helper(county_feat=False)
|
||||
|
||||
def test_model_inheritance(self):
|
||||
"Tests LayerMapping on inherited models. See #12093."
|
||||
icity_mapping = {'name': 'Name',
|
||||
'population': 'Population',
|
||||
'density': 'Density',
|
||||
'point': 'POINT',
|
||||
'dt': 'Created',
|
||||
}
|
||||
|
||||
# Parent model has geometry field.
|
||||
lm1 = LayerMapping(ICity1, city_shp, icity_mapping)
|
||||
lm1.save()
|
||||
|
||||
# Grandparent has geometry field.
|
||||
lm2 = LayerMapping(ICity2, city_shp, icity_mapping)
|
||||
lm2.save()
|
||||
|
||||
self.assertEqual(6, ICity1.objects.count())
|
||||
self.assertEqual(3, ICity2.objects.count())
|
||||
|
||||
def test_invalid_layer(self):
|
||||
"Tests LayerMapping on invalid geometries. See #15378."
|
||||
invalid_mapping = {'point': 'POINT'}
|
||||
lm = LayerMapping(Invalid, invalid_shp, invalid_mapping,
|
||||
source_srs=4326)
|
||||
lm.save(silent=True)
|
||||
|
||||
def test_charfield_too_short(self):
|
||||
mapping = copy(city_mapping)
|
||||
mapping['name_short'] = 'Name'
|
||||
lm = LayerMapping(City, city_shp, mapping)
|
||||
with self.assertRaises(InvalidString):
|
||||
lm.save(silent=True, strict=True)
|
||||
|
||||
def test_textfield(self):
|
||||
"Tests that String content fits also in a TextField"
|
||||
mapping = copy(city_mapping)
|
||||
mapping['name_txt'] = 'Name'
|
||||
lm = LayerMapping(City, city_shp, mapping)
|
||||
lm.save(silent=True, strict=True)
|
||||
self.assertEqual(City.objects.count(), 3)
|
||||
self.assertEqual(City.objects.get(name='Houston').name_txt, "Houston")
|
||||
|
||||
def test_encoded_name(self):
|
||||
""" Test a layer containing utf-8-encoded name """
|
||||
city_shp = os.path.join(shp_path, 'ch-city', 'ch-city.shp')
|
||||
lm = LayerMapping(City, city_shp, city_mapping)
|
||||
lm.save(silent=True, strict=True)
|
||||
self.assertEqual(City.objects.count(), 1)
|
||||
self.assertEqual(City.objects.all()[0].name, "Zürich")
|
||||
|
||||
|
||||
class OtherRouter(object):
|
||||
def db_for_read(self, model, **hints):
|
||||
return 'other'
|
||||
|
||||
def db_for_write(self, model, **hints):
|
||||
return self.db_for_read(model, **hints)
|
||||
|
||||
def allow_relation(self, obj1, obj2, **hints):
|
||||
return None
|
||||
|
||||
def allow_migrate(self, db, model):
|
||||
return True
|
||||
|
||||
|
||||
@skipUnless(HAS_GDAL, "LayerMapRouterTest needs GDAL support")
|
||||
@skipUnlessDBFeature("gis_enabled")
|
||||
@override_settings(DATABASE_ROUTERS=[OtherRouter()])
|
||||
class LayerMapRouterTest(TestCase):
|
||||
|
||||
@unittest.skipUnless(len(settings.DATABASES) > 1, 'multiple databases required')
|
||||
def test_layermapping_default_db(self):
|
||||
lm = LayerMapping(City, city_shp, city_mapping)
|
||||
self.assertEqual(lm.using, 'other')
|
||||
@@ -1,40 +0,0 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
from __future__ import unicode_literals
|
||||
|
||||
from unittest import skipUnless
|
||||
|
||||
from django.contrib.gis.geos import HAS_GEOS
|
||||
from django.test import TestCase
|
||||
from django.test.utils import override_settings
|
||||
|
||||
GOOGLE_MAPS_API_KEY = 'XXXX'
|
||||
|
||||
|
||||
@skipUnless(HAS_GEOS, 'Geos is required.')
|
||||
class GoogleMapsTest(TestCase):
|
||||
|
||||
@override_settings(GOOGLE_MAPS_API_KEY=GOOGLE_MAPS_API_KEY)
|
||||
def test_google_map_scripts(self):
|
||||
"""
|
||||
Testing GoogleMap.scripts() output. See #20773.
|
||||
"""
|
||||
from django.contrib.gis.maps.google.gmap import GoogleMap
|
||||
|
||||
google_map = GoogleMap()
|
||||
scripts = google_map.scripts
|
||||
self.assertIn(GOOGLE_MAPS_API_KEY, scripts)
|
||||
self.assertIn("new GMap2", scripts)
|
||||
|
||||
@override_settings(GOOGLE_MAPS_API_KEY=GOOGLE_MAPS_API_KEY)
|
||||
def test_unicode_in_google_maps(self):
|
||||
"""
|
||||
Test that GoogleMap doesn't crash with non-ASCII content.
|
||||
"""
|
||||
from django.contrib.gis.geos import Point
|
||||
from django.contrib.gis.maps.google.gmap import GoogleMap, GMarker
|
||||
|
||||
center = Point(6.146805, 46.227574)
|
||||
marker = GMarker(center,
|
||||
title='En français !')
|
||||
google_map = GoogleMap(center=center, zoom=18, markers=[marker])
|
||||
self.assertIn("En français", google_map.scripts)
|
||||
@@ -1,139 +0,0 @@
|
||||
[
|
||||
{
|
||||
"pk": 1,
|
||||
"model": "relatedapp.location",
|
||||
"fields": {
|
||||
"point": "SRID=4326;POINT (-97.516111 33.058333)"
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 2,
|
||||
"model": "relatedapp.location",
|
||||
"fields": {
|
||||
"point": "SRID=4326;POINT (-104.528056 33.387222)"
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 3,
|
||||
"model": "relatedapp.location",
|
||||
"fields": {
|
||||
"point": "SRID=4326;POINT (-79.460734 40.18476)"
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 4,
|
||||
"model": "relatedapp.location",
|
||||
"fields": {
|
||||
"point": "SRID=4326;POINT (-95.363151 29.763374)"
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 5,
|
||||
"model": "relatedapp.location",
|
||||
"fields": {
|
||||
"point": "SRID=4326;POINT (-96.801611 32.782057)"
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 1,
|
||||
"model": "relatedapp.city",
|
||||
"fields": {
|
||||
"name": "Aurora",
|
||||
"state": "TX",
|
||||
"location": 1
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 2,
|
||||
"model": "relatedapp.city",
|
||||
"fields": {
|
||||
"name": "Roswell",
|
||||
"state": "NM",
|
||||
"location": 2
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 3,
|
||||
"model": "relatedapp.city",
|
||||
"fields": {
|
||||
"name": "Kecksburg",
|
||||
"state": "PA",
|
||||
"location": 3
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 4,
|
||||
"model": "relatedapp.city",
|
||||
"fields": {
|
||||
"name": "Dallas",
|
||||
"state": "TX",
|
||||
"location": 5
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 5,
|
||||
"model": "relatedapp.city",
|
||||
"fields": {
|
||||
"name": "Houston",
|
||||
"state": "TX",
|
||||
"location": 4
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 6,
|
||||
"model": "relatedapp.city",
|
||||
"fields": {
|
||||
"name": "Fort Worth",
|
||||
"state": "TX",
|
||||
"location": 5
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 1,
|
||||
"model": "relatedapp.Author",
|
||||
"fields": {
|
||||
"name": "Trevor Paglen",
|
||||
"dob": "1974-5-23"
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 2,
|
||||
"model": "relatedapp.Author",
|
||||
"fields": {
|
||||
"name": "William Patry",
|
||||
"dob": "1950-1-1"
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 1,
|
||||
"model": "relatedapp.Book",
|
||||
"fields": {
|
||||
"title": "Torture Taxi",
|
||||
"author": 1
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 2,
|
||||
"model": "relatedapp.Book",
|
||||
"fields": {
|
||||
"title": "I Could Tell You But Then You Would Have to be Destroyed by Me",
|
||||
"author": 1
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 3,
|
||||
"model": "relatedapp.Book",
|
||||
"fields": {
|
||||
"title": "Blank Spots on the Map",
|
||||
"author": 1
|
||||
}
|
||||
},
|
||||
{
|
||||
"pk": 4,
|
||||
"model": "relatedapp.Book",
|
||||
"fields": {
|
||||
"title": "Patry on Copyright",
|
||||
"author": 2
|
||||
}
|
||||
}
|
||||
]
|
||||
@@ -1,78 +0,0 @@
|
||||
from django.contrib.gis.db import models
|
||||
from django.utils.encoding import python_2_unicode_compatible
|
||||
|
||||
|
||||
class SimpleModel(models.Model):
|
||||
|
||||
objects = models.GeoManager()
|
||||
|
||||
class Meta:
|
||||
abstract = True
|
||||
app_label = 'relatedapp'
|
||||
|
||||
|
||||
@python_2_unicode_compatible
|
||||
class Location(SimpleModel):
|
||||
point = models.PointField()
|
||||
|
||||
def __str__(self):
|
||||
return self.point.wkt
|
||||
|
||||
|
||||
@python_2_unicode_compatible
|
||||
class City(SimpleModel):
|
||||
name = models.CharField(max_length=50)
|
||||
state = models.CharField(max_length=2)
|
||||
location = models.ForeignKey(Location)
|
||||
|
||||
def __str__(self):
|
||||
return self.name
|
||||
|
||||
|
||||
class AugmentedLocation(Location):
|
||||
extra_text = models.TextField(blank=True)
|
||||
|
||||
objects = models.GeoManager()
|
||||
|
||||
class Meta:
|
||||
app_label = 'relatedapp'
|
||||
|
||||
|
||||
class DirectoryEntry(SimpleModel):
|
||||
listing_text = models.CharField(max_length=50)
|
||||
location = models.ForeignKey(AugmentedLocation)
|
||||
|
||||
|
||||
@python_2_unicode_compatible
|
||||
class Parcel(SimpleModel):
|
||||
name = models.CharField(max_length=30)
|
||||
city = models.ForeignKey(City)
|
||||
center1 = models.PointField()
|
||||
# Throwing a curveball w/`db_column` here.
|
||||
center2 = models.PointField(srid=2276, db_column='mycenter')
|
||||
border1 = models.PolygonField()
|
||||
border2 = models.PolygonField(srid=2276)
|
||||
|
||||
def __str__(self):
|
||||
return self.name
|
||||
|
||||
|
||||
# These use the GeoManager but do not have any geographic fields.
|
||||
class Author(SimpleModel):
|
||||
name = models.CharField(max_length=100)
|
||||
dob = models.DateField()
|
||||
|
||||
|
||||
class Article(SimpleModel):
|
||||
title = models.CharField(max_length=100)
|
||||
author = models.ForeignKey(Author, unique=True)
|
||||
|
||||
|
||||
class Book(SimpleModel):
|
||||
title = models.CharField(max_length=100)
|
||||
author = models.ForeignKey(Author, related_name='books', null=True)
|
||||
|
||||
|
||||
class Event(SimpleModel):
|
||||
name = models.CharField(max_length=100)
|
||||
when = models.DateTimeField()
|
||||
@@ -1,335 +0,0 @@
|
||||
from __future__ import unicode_literals
|
||||
|
||||
from django.contrib.gis.geos import HAS_GEOS
|
||||
from django.contrib.gis.tests.utils import no_oracle
|
||||
from django.db import connection
|
||||
from django.test import TestCase, ignore_warnings, skipUnlessDBFeature
|
||||
from django.test.utils import override_settings
|
||||
from django.utils import timezone
|
||||
from django.utils.deprecation import RemovedInDjango20Warning
|
||||
|
||||
if HAS_GEOS:
|
||||
from django.contrib.gis.db.models import Collect, Count, Extent, F, Union
|
||||
from django.contrib.gis.geometry.backend import Geometry
|
||||
from django.contrib.gis.geos import GEOSGeometry, Point, MultiPoint
|
||||
|
||||
from .models import City, Location, DirectoryEntry, Parcel, Book, Author, Article, Event
|
||||
|
||||
|
||||
@skipUnlessDBFeature("gis_enabled")
|
||||
class RelatedGeoModelTest(TestCase):
|
||||
fixtures = ['initial']
|
||||
|
||||
def test02_select_related(self):
|
||||
"Testing `select_related` on geographic models (see #7126)."
|
||||
qs1 = City.objects.order_by('id')
|
||||
qs2 = City.objects.order_by('id').select_related()
|
||||
qs3 = City.objects.order_by('id').select_related('location')
|
||||
|
||||
# Reference data for what's in the fixtures.
|
||||
cities = (
|
||||
('Aurora', 'TX', -97.516111, 33.058333),
|
||||
('Roswell', 'NM', -104.528056, 33.387222),
|
||||
('Kecksburg', 'PA', -79.460734, 40.18476),
|
||||
)
|
||||
|
||||
for qs in (qs1, qs2, qs3):
|
||||
for ref, c in zip(cities, qs):
|
||||
nm, st, lon, lat = ref
|
||||
self.assertEqual(nm, c.name)
|
||||
self.assertEqual(st, c.state)
|
||||
self.assertEqual(Point(lon, lat), c.location.point)
|
||||
|
||||
@skipUnlessDBFeature("has_transform_method")
|
||||
def test03_transform_related(self):
|
||||
"Testing the `transform` GeoQuerySet method on related geographic models."
|
||||
# All the transformations are to state plane coordinate systems using
|
||||
# US Survey Feet (thus a tolerance of 0 implies error w/in 1 survey foot).
|
||||
tol = 0
|
||||
|
||||
def check_pnt(ref, pnt):
|
||||
self.assertAlmostEqual(ref.x, pnt.x, tol)
|
||||
self.assertAlmostEqual(ref.y, pnt.y, tol)
|
||||
self.assertEqual(ref.srid, pnt.srid)
|
||||
|
||||
# Each city transformed to the SRID of their state plane coordinate system.
|
||||
transformed = (('Kecksburg', 2272, 'POINT(1490553.98959621 314792.131023984)'),
|
||||
('Roswell', 2257, 'POINT(481902.189077221 868477.766629735)'),
|
||||
('Aurora', 2276, 'POINT(2269923.2484839 7069381.28722222)'),
|
||||
)
|
||||
|
||||
for name, srid, wkt in transformed:
|
||||
# Doing this implicitly sets `select_related` select the location.
|
||||
# TODO: Fix why this breaks on Oracle.
|
||||
qs = list(City.objects.filter(name=name).transform(srid, field_name='location__point'))
|
||||
check_pnt(GEOSGeometry(wkt, srid), qs[0].location.point)
|
||||
|
||||
@skipUnlessDBFeature("supports_extent_aggr")
|
||||
@ignore_warnings(category=RemovedInDjango20Warning)
|
||||
def test_related_extent_aggregate(self):
|
||||
"Testing the `extent` GeoQuerySet aggregates on related geographic models."
|
||||
# This combines the Extent and Union aggregates into one query
|
||||
aggs = City.objects.aggregate(Extent('location__point'))
|
||||
|
||||
# One for all locations, one that excludes New Mexico (Roswell).
|
||||
all_extent = (-104.528056, 29.763374, -79.460734, 40.18476)
|
||||
txpa_extent = (-97.516111, 29.763374, -79.460734, 40.18476)
|
||||
e1 = City.objects.extent(field_name='location__point')
|
||||
e2 = City.objects.exclude(state='NM').extent(field_name='location__point')
|
||||
e3 = aggs['location__point__extent']
|
||||
|
||||
# The tolerance value is to four decimal places because of differences
|
||||
# between the Oracle and PostGIS spatial backends on the extent calculation.
|
||||
tol = 4
|
||||
for ref, e in [(all_extent, e1), (txpa_extent, e2), (all_extent, e3)]:
|
||||
for ref_val, e_val in zip(ref, e):
|
||||
self.assertAlmostEqual(ref_val, e_val, tol)
|
||||
|
||||
@skipUnlessDBFeature("supports_extent_aggr")
|
||||
def test_related_extent_annotate(self):
|
||||
"""
|
||||
Test annotation with Extent GeoAggregate.
|
||||
"""
|
||||
cities = City.objects.annotate(points_extent=Extent('location__point')).order_by('name')
|
||||
tol = 4
|
||||
self.assertAlmostEqual(
|
||||
cities[0].points_extent,
|
||||
(-97.516111, 33.058333, -97.516111, 33.058333),
|
||||
tol
|
||||
)
|
||||
|
||||
@skipUnlessDBFeature("has_unionagg_method")
|
||||
@ignore_warnings(category=RemovedInDjango20Warning)
|
||||
def test_related_union_aggregate(self):
|
||||
"Testing the `unionagg` GeoQuerySet aggregates on related geographic models."
|
||||
# This combines the Extent and Union aggregates into one query
|
||||
aggs = City.objects.aggregate(Union('location__point'))
|
||||
|
||||
# These are the points that are components of the aggregate geographic
|
||||
# union that is returned. Each point # corresponds to City PK.
|
||||
p1 = Point(-104.528056, 33.387222)
|
||||
p2 = Point(-97.516111, 33.058333)
|
||||
p3 = Point(-79.460734, 40.18476)
|
||||
p4 = Point(-96.801611, 32.782057)
|
||||
p5 = Point(-95.363151, 29.763374)
|
||||
|
||||
# The second union aggregate is for a union
|
||||
# query that includes limiting information in the WHERE clause (in other
|
||||
# words a `.filter()` precedes the call to `.unionagg()`).
|
||||
ref_u1 = MultiPoint(p1, p2, p4, p5, p3, srid=4326)
|
||||
ref_u2 = MultiPoint(p2, p3, srid=4326)
|
||||
|
||||
u1 = City.objects.unionagg(field_name='location__point')
|
||||
u2 = City.objects.exclude(
|
||||
name__in=('Roswell', 'Houston', 'Dallas', 'Fort Worth'),
|
||||
).unionagg(field_name='location__point')
|
||||
u3 = aggs['location__point__union']
|
||||
self.assertEqual(type(u1), MultiPoint)
|
||||
self.assertEqual(type(u3), MultiPoint)
|
||||
|
||||
# Ordering of points in the result of the union is not defined and
|
||||
# implementation-dependent (DB backend, GEOS version)
|
||||
self.assertSetEqual({p.ewkt for p in ref_u1}, {p.ewkt for p in u1})
|
||||
self.assertSetEqual({p.ewkt for p in ref_u2}, {p.ewkt for p in u2})
|
||||
self.assertSetEqual({p.ewkt for p in ref_u1}, {p.ewkt for p in u3})
|
||||
|
||||
def test05_select_related_fk_to_subclass(self):
|
||||
"Testing that calling select_related on a query over a model with an FK to a model subclass works"
|
||||
# Regression test for #9752.
|
||||
list(DirectoryEntry.objects.all().select_related())
|
||||
|
||||
def test06_f_expressions(self):
|
||||
"Testing F() expressions on GeometryFields."
|
||||
# Constructing a dummy parcel border and getting the City instance for
|
||||
# assigning the FK.
|
||||
b1 = GEOSGeometry(
|
||||
'POLYGON((-97.501205 33.052520,-97.501205 33.052576,'
|
||||
'-97.501150 33.052576,-97.501150 33.052520,-97.501205 33.052520))',
|
||||
srid=4326
|
||||
)
|
||||
pcity = City.objects.get(name='Aurora')
|
||||
|
||||
# First parcel has incorrect center point that is equal to the City;
|
||||
# it also has a second border that is different from the first as a
|
||||
# 100ft buffer around the City.
|
||||
c1 = pcity.location.point
|
||||
c2 = c1.transform(2276, clone=True)
|
||||
b2 = c2.buffer(100)
|
||||
Parcel.objects.create(name='P1', city=pcity, center1=c1, center2=c2, border1=b1, border2=b2)
|
||||
|
||||
# Now creating a second Parcel where the borders are the same, just
|
||||
# in different coordinate systems. The center points are also the
|
||||
# same (but in different coordinate systems), and this time they
|
||||
# actually correspond to the centroid of the border.
|
||||
c1 = b1.centroid
|
||||
c2 = c1.transform(2276, clone=True)
|
||||
Parcel.objects.create(name='P2', city=pcity, center1=c1, center2=c2, border1=b1, border2=b1)
|
||||
|
||||
# Should return the second Parcel, which has the center within the
|
||||
# border.
|
||||
qs = Parcel.objects.filter(center1__within=F('border1'))
|
||||
self.assertEqual(1, len(qs))
|
||||
self.assertEqual('P2', qs[0].name)
|
||||
|
||||
if connection.features.supports_transform:
|
||||
# This time center2 is in a different coordinate system and needs
|
||||
# to be wrapped in transformation SQL.
|
||||
qs = Parcel.objects.filter(center2__within=F('border1'))
|
||||
self.assertEqual(1, len(qs))
|
||||
self.assertEqual('P2', qs[0].name)
|
||||
|
||||
# Should return the first Parcel, which has the center point equal
|
||||
# to the point in the City ForeignKey.
|
||||
qs = Parcel.objects.filter(center1=F('city__location__point'))
|
||||
self.assertEqual(1, len(qs))
|
||||
self.assertEqual('P1', qs[0].name)
|
||||
|
||||
if connection.features.supports_transform:
|
||||
# This time the city column should be wrapped in transformation SQL.
|
||||
qs = Parcel.objects.filter(border2__contains=F('city__location__point'))
|
||||
self.assertEqual(1, len(qs))
|
||||
self.assertEqual('P1', qs[0].name)
|
||||
|
||||
def test07_values(self):
|
||||
"Testing values() and values_list() and GeoQuerySets."
|
||||
# GeoQuerySet and GeoValuesQuerySet, and GeoValuesListQuerySet respectively.
|
||||
gqs = Location.objects.all()
|
||||
gvqs = Location.objects.values()
|
||||
gvlqs = Location.objects.values_list()
|
||||
|
||||
# Incrementing through each of the models, dictionaries, and tuples
|
||||
# returned by the different types of GeoQuerySets.
|
||||
for m, d, t in zip(gqs, gvqs, gvlqs):
|
||||
# The values should be Geometry objects and not raw strings returned
|
||||
# by the spatial database.
|
||||
self.assertIsInstance(d['point'], Geometry)
|
||||
self.assertIsInstance(t[1], Geometry)
|
||||
self.assertEqual(m.point, d['point'])
|
||||
self.assertEqual(m.point, t[1])
|
||||
|
||||
@override_settings(USE_TZ=True)
|
||||
def test_07b_values(self):
|
||||
"Testing values() and values_list() with aware datetime. See #21565."
|
||||
Event.objects.create(name="foo", when=timezone.now())
|
||||
list(Event.objects.values_list('when'))
|
||||
|
||||
def test08_defer_only(self):
|
||||
"Testing defer() and only() on Geographic models."
|
||||
qs = Location.objects.all()
|
||||
def_qs = Location.objects.defer('point')
|
||||
for loc, def_loc in zip(qs, def_qs):
|
||||
self.assertEqual(loc.point, def_loc.point)
|
||||
|
||||
def test09_pk_relations(self):
|
||||
"Ensuring correct primary key column is selected across relations. See #10757."
|
||||
# The expected ID values -- notice the last two location IDs
|
||||
# are out of order. Dallas and Houston have location IDs that differ
|
||||
# from their PKs -- this is done to ensure that the related location
|
||||
# ID column is selected instead of ID column for the city.
|
||||
city_ids = (1, 2, 3, 4, 5)
|
||||
loc_ids = (1, 2, 3, 5, 4)
|
||||
ids_qs = City.objects.order_by('id').values('id', 'location__id')
|
||||
for val_dict, c_id, l_id in zip(ids_qs, city_ids, loc_ids):
|
||||
self.assertEqual(val_dict['id'], c_id)
|
||||
self.assertEqual(val_dict['location__id'], l_id)
|
||||
|
||||
# TODO: fix on Oracle -- qs2 returns an empty result for an unknown reason
|
||||
@no_oracle
|
||||
def test10_combine(self):
|
||||
"Testing the combination of two GeoQuerySets. See #10807."
|
||||
buf1 = City.objects.get(name='Aurora').location.point.buffer(0.1)
|
||||
buf2 = City.objects.get(name='Kecksburg').location.point.buffer(0.1)
|
||||
qs1 = City.objects.filter(location__point__within=buf1)
|
||||
qs2 = City.objects.filter(location__point__within=buf2)
|
||||
combined = qs1 | qs2
|
||||
names = [c.name for c in combined]
|
||||
self.assertEqual(2, len(names))
|
||||
self.assertIn('Aurora', names)
|
||||
self.assertIn('Kecksburg', names)
|
||||
|
||||
# TODO: fix on Oracle -- get the following error because the SQL is ordered
|
||||
# by a geometry object, which Oracle apparently doesn't like:
|
||||
# ORA-22901: cannot compare nested table or VARRAY or LOB attributes of an object type
|
||||
@no_oracle
|
||||
def test12a_count(self):
|
||||
"Testing `Count` aggregate use with the `GeoManager` on geo-fields."
|
||||
# The City, 'Fort Worth' uses the same location as Dallas.
|
||||
dallas = City.objects.get(name='Dallas')
|
||||
|
||||
# Count annotation should be 2 for the Dallas location now.
|
||||
loc = Location.objects.annotate(num_cities=Count('city')).get(id=dallas.location.id)
|
||||
self.assertEqual(2, loc.num_cities)
|
||||
|
||||
def test12b_count(self):
|
||||
"Testing `Count` aggregate use with the `GeoManager` on non geo-fields. See #11087."
|
||||
# Should only be one author (Trevor Paglen) returned by this query, and
|
||||
# the annotation should have 3 for the number of books, see #11087.
|
||||
# Also testing with a `GeoValuesQuerySet`, see #11489.
|
||||
qs = Author.objects.annotate(num_books=Count('books')).filter(num_books__gt=1)
|
||||
vqs = Author.objects.values('name').annotate(num_books=Count('books')).filter(num_books__gt=1)
|
||||
self.assertEqual(1, len(qs))
|
||||
self.assertEqual(3, qs[0].num_books)
|
||||
self.assertEqual(1, len(vqs))
|
||||
self.assertEqual(3, vqs[0]['num_books'])
|
||||
|
||||
# TODO: fix on Oracle -- get the following error because the SQL is ordered
|
||||
# by a geometry object, which Oracle apparently doesn't like:
|
||||
# ORA-22901: cannot compare nested table or VARRAY or LOB attributes of an object type
|
||||
@no_oracle
|
||||
def test13c_count(self):
|
||||
"Testing `Count` aggregate with `.values()`. See #15305."
|
||||
qs = Location.objects.filter(id=5).annotate(num_cities=Count('city')).values('id', 'point', 'num_cities')
|
||||
self.assertEqual(1, len(qs))
|
||||
self.assertEqual(2, qs[0]['num_cities'])
|
||||
self.assertIsInstance(qs[0]['point'], GEOSGeometry)
|
||||
|
||||
# TODO: The phantom model does appear on Oracle.
|
||||
@no_oracle
|
||||
def test13_select_related_null_fk(self):
|
||||
"Testing `select_related` on a nullable ForeignKey via `GeoManager`. See #11381."
|
||||
Book.objects.create(title='Without Author')
|
||||
b = Book.objects.select_related('author').get(title='Without Author')
|
||||
# Should be `None`, and not a 'dummy' model.
|
||||
self.assertEqual(None, b.author)
|
||||
|
||||
@skipUnlessDBFeature("supports_collect_aggr")
|
||||
@ignore_warnings(category=RemovedInDjango20Warning)
|
||||
def test_collect(self):
|
||||
"""
|
||||
Testing the (deprecated) `collect` GeoQuerySet method and `Collect`
|
||||
aggregate.
|
||||
"""
|
||||
# Reference query:
|
||||
# SELECT AsText(ST_Collect("relatedapp_location"."point")) FROM "relatedapp_city" LEFT OUTER JOIN
|
||||
# "relatedapp_location" ON ("relatedapp_city"."location_id" = "relatedapp_location"."id")
|
||||
# WHERE "relatedapp_city"."state" = 'TX';
|
||||
ref_geom = GEOSGeometry(
|
||||
'MULTIPOINT(-97.516111 33.058333,-96.801611 32.782057,'
|
||||
'-95.363151 29.763374,-96.801611 32.782057)'
|
||||
)
|
||||
|
||||
c1 = City.objects.filter(state='TX').collect(field_name='location__point')
|
||||
c2 = City.objects.filter(state='TX').aggregate(Collect('location__point'))['location__point__collect']
|
||||
|
||||
for coll in (c1, c2):
|
||||
# Even though Dallas and Ft. Worth share same point, Collect doesn't
|
||||
# consolidate -- that's why 4 points in MultiPoint.
|
||||
self.assertEqual(4, len(coll))
|
||||
self.assertTrue(ref_geom.equals(coll))
|
||||
|
||||
def test15_invalid_select_related(self):
|
||||
"Testing doing select_related on the related name manager of a unique FK. See #13934."
|
||||
qs = Article.objects.select_related('author__article')
|
||||
# This triggers TypeError when `get_default_columns` has no `local_only`
|
||||
# keyword. The TypeError is swallowed if QuerySet is actually
|
||||
# evaluated as list generation swallows TypeError in CPython.
|
||||
str(qs.query)
|
||||
|
||||
def test16_annotated_date_queryset(self):
|
||||
"Ensure annotated date querysets work if spatial backend is used. See #14648."
|
||||
birth_years = [dt.year for dt in
|
||||
list(Author.objects.annotate(num_books=Count('books')).dates('dob', 'year'))]
|
||||
birth_years.sort()
|
||||
self.assertEqual([1950, 1974], birth_years)
|
||||
|
||||
# TODO: Related tests for KML, GML, and distance lookups.
|
||||
@@ -1,335 +0,0 @@
|
||||
from unittest import skipUnless
|
||||
|
||||
from django.contrib.gis.gdal import HAS_GDAL
|
||||
from django.forms import ValidationError
|
||||
from django.test import SimpleTestCase, skipUnlessDBFeature
|
||||
from django.utils import six
|
||||
from django.utils.html import escape
|
||||
|
||||
if HAS_GDAL:
|
||||
from django.contrib.gis import forms
|
||||
from django.contrib.gis.geos import GEOSGeometry
|
||||
|
||||
|
||||
@skipUnless(HAS_GDAL, "GeometryFieldTest needs GDAL support")
|
||||
@skipUnlessDBFeature("gis_enabled")
|
||||
class GeometryFieldTest(SimpleTestCase):
|
||||
|
||||
def test_init(self):
|
||||
"Testing GeometryField initialization with defaults."
|
||||
fld = forms.GeometryField()
|
||||
for bad_default in ('blah', 3, 'FoO', None, 0):
|
||||
self.assertRaises(ValidationError, fld.clean, bad_default)
|
||||
|
||||
def test_srid(self):
|
||||
"Testing GeometryField with a SRID set."
|
||||
# Input that doesn't specify the SRID is assumed to be in the SRID
|
||||
# of the input field.
|
||||
fld = forms.GeometryField(srid=4326)
|
||||
geom = fld.clean('POINT(5 23)')
|
||||
self.assertEqual(4326, geom.srid)
|
||||
# Making the field in a different SRID from that of the geometry, and
|
||||
# asserting it transforms.
|
||||
fld = forms.GeometryField(srid=32140)
|
||||
tol = 0.0000001
|
||||
xform_geom = GEOSGeometry('POINT (951640.547328465 4219369.26171664)', srid=32140)
|
||||
# The cleaned geometry should be transformed to 32140.
|
||||
cleaned_geom = fld.clean('SRID=4326;POINT (-95.363151 29.763374)')
|
||||
self.assertTrue(xform_geom.equals_exact(cleaned_geom, tol))
|
||||
|
||||
def test_null(self):
|
||||
"Testing GeometryField's handling of null (None) geometries."
|
||||
# Form fields, by default, are required (`required=True`)
|
||||
fld = forms.GeometryField()
|
||||
with six.assertRaisesRegex(self, forms.ValidationError,
|
||||
"No geometry value provided."):
|
||||
fld.clean(None)
|
||||
|
||||
# This will clean None as a geometry (See #10660).
|
||||
fld = forms.GeometryField(required=False)
|
||||
self.assertIsNone(fld.clean(None))
|
||||
|
||||
def test_geom_type(self):
|
||||
"Testing GeometryField's handling of different geometry types."
|
||||
# By default, all geometry types are allowed.
|
||||
fld = forms.GeometryField()
|
||||
for wkt in ('POINT(5 23)', 'MULTIPOLYGON(((0 0, 0 1, 1 1, 1 0, 0 0)))', 'LINESTRING(0 0, 1 1)'):
|
||||
self.assertEqual(GEOSGeometry(wkt), fld.clean(wkt))
|
||||
|
||||
pnt_fld = forms.GeometryField(geom_type='POINT')
|
||||
self.assertEqual(GEOSGeometry('POINT(5 23)'), pnt_fld.clean('POINT(5 23)'))
|
||||
# a WKT for any other geom_type will be properly transformed by `to_python`
|
||||
self.assertEqual(GEOSGeometry('LINESTRING(0 0, 1 1)'), pnt_fld.to_python('LINESTRING(0 0, 1 1)'))
|
||||
# but rejected by `clean`
|
||||
self.assertRaises(forms.ValidationError, pnt_fld.clean, 'LINESTRING(0 0, 1 1)')
|
||||
|
||||
def test_to_python(self):
|
||||
"""
|
||||
Testing to_python returns a correct GEOSGeometry object or
|
||||
a ValidationError
|
||||
"""
|
||||
fld = forms.GeometryField()
|
||||
# to_python returns the same GEOSGeometry for a WKT
|
||||
for wkt in ('POINT(5 23)', 'MULTIPOLYGON(((0 0, 0 1, 1 1, 1 0, 0 0)))', 'LINESTRING(0 0, 1 1)'):
|
||||
self.assertEqual(GEOSGeometry(wkt), fld.to_python(wkt))
|
||||
# but raises a ValidationError for any other string
|
||||
for wkt in ('POINT(5)', 'MULTI POLYGON(((0 0, 0 1, 1 1, 1 0, 0 0)))', 'BLAH(0 0, 1 1)'):
|
||||
self.assertRaises(forms.ValidationError, fld.to_python, wkt)
|
||||
|
||||
def test_field_with_text_widget(self):
|
||||
class PointForm(forms.Form):
|
||||
pt = forms.PointField(srid=4326, widget=forms.TextInput)
|
||||
|
||||
form = PointForm()
|
||||
cleaned_pt = form.fields['pt'].clean('POINT(5 23)')
|
||||
self.assertEqual(cleaned_pt, GEOSGeometry('POINT(5 23)'))
|
||||
self.assertEqual(4326, cleaned_pt.srid)
|
||||
|
||||
point = GEOSGeometry('SRID=4326;POINT(5 23)')
|
||||
form = PointForm(data={'pt': 'POINT(5 23)'}, initial={'pt': point})
|
||||
self.assertFalse(form.has_changed())
|
||||
|
||||
|
||||
@skipUnless(HAS_GDAL, "SpecializedFieldTest needs GDAL support")
|
||||
@skipUnlessDBFeature("gis_enabled")
|
||||
class SpecializedFieldTest(SimpleTestCase):
|
||||
def setUp(self):
|
||||
self.geometries = {
|
||||
'point': GEOSGeometry("SRID=4326;POINT(9.052734375 42.451171875)"),
|
||||
'multipoint': GEOSGeometry("SRID=4326;MULTIPOINT("
|
||||
"(13.18634033203125 14.504356384277344),"
|
||||
"(13.207969665527 14.490966796875),"
|
||||
"(13.177070617675 14.454917907714))"),
|
||||
'linestring': GEOSGeometry("SRID=4326;LINESTRING("
|
||||
"-8.26171875 -0.52734375,"
|
||||
"-7.734375 4.21875,"
|
||||
"6.85546875 3.779296875,"
|
||||
"5.44921875 -3.515625)"),
|
||||
'multilinestring': GEOSGeometry("SRID=4326;MULTILINESTRING("
|
||||
"(-16.435546875 -2.98828125,"
|
||||
"-17.2265625 2.98828125,"
|
||||
"-0.703125 3.515625,"
|
||||
"-1.494140625 -3.33984375),"
|
||||
"(-8.0859375 -5.9765625,"
|
||||
"8.525390625 -8.7890625,"
|
||||
"12.392578125 -0.87890625,"
|
||||
"10.01953125 7.646484375))"),
|
||||
'polygon': GEOSGeometry("SRID=4326;POLYGON("
|
||||
"(-1.669921875 6.240234375,"
|
||||
"-3.8671875 -0.615234375,"
|
||||
"5.9765625 -3.955078125,"
|
||||
"18.193359375 3.955078125,"
|
||||
"9.84375 9.4921875,"
|
||||
"-1.669921875 6.240234375))"),
|
||||
'multipolygon': GEOSGeometry("SRID=4326;MULTIPOLYGON("
|
||||
"((-17.578125 13.095703125,"
|
||||
"-17.2265625 10.8984375,"
|
||||
"-13.974609375 10.1953125,"
|
||||
"-13.359375 12.744140625,"
|
||||
"-15.732421875 13.7109375,"
|
||||
"-17.578125 13.095703125)),"
|
||||
"((-8.525390625 5.537109375,"
|
||||
"-8.876953125 2.548828125,"
|
||||
"-5.888671875 1.93359375,"
|
||||
"-5.09765625 4.21875,"
|
||||
"-6.064453125 6.240234375,"
|
||||
"-8.525390625 5.537109375)))"),
|
||||
'geometrycollection': GEOSGeometry("SRID=4326;GEOMETRYCOLLECTION("
|
||||
"POINT(5.625 -0.263671875),"
|
||||
"POINT(6.767578125 -3.603515625),"
|
||||
"POINT(8.525390625 0.087890625),"
|
||||
"POINT(8.0859375 -2.13134765625),"
|
||||
"LINESTRING("
|
||||
"6.273193359375 -1.175537109375,"
|
||||
"5.77880859375 -1.812744140625,"
|
||||
"7.27294921875 -2.230224609375,"
|
||||
"7.657470703125 -1.25244140625))"),
|
||||
}
|
||||
|
||||
def assertMapWidget(self, form_instance):
|
||||
"""
|
||||
Make sure the MapWidget js is passed in the form media and a MapWidget
|
||||
is actually created
|
||||
"""
|
||||
self.assertTrue(form_instance.is_valid())
|
||||
rendered = form_instance.as_p()
|
||||
self.assertIn('new MapWidget(options);', rendered)
|
||||
self.assertIn('gis/js/OLMapWidget.js', str(form_instance.media))
|
||||
|
||||
def assertTextarea(self, geom, rendered):
|
||||
"""Makes sure the wkt and a textarea are in the content"""
|
||||
|
||||
self.assertIn('<textarea ', rendered)
|
||||
self.assertIn('required', rendered)
|
||||
self.assertIn(geom.wkt, rendered)
|
||||
|
||||
def test_pointfield(self):
|
||||
class PointForm(forms.Form):
|
||||
p = forms.PointField()
|
||||
|
||||
geom = self.geometries['point']
|
||||
form = PointForm(data={'p': geom})
|
||||
self.assertTextarea(geom, form.as_p())
|
||||
self.assertMapWidget(form)
|
||||
self.assertFalse(PointForm().is_valid())
|
||||
invalid = PointForm(data={'p': 'some invalid geom'})
|
||||
self.assertFalse(invalid.is_valid())
|
||||
self.assertIn('Invalid geometry value', str(invalid.errors))
|
||||
|
||||
for invalid in [geo for key, geo in self.geometries.items() if key != 'point']:
|
||||
self.assertFalse(PointForm(data={'p': invalid.wkt}).is_valid())
|
||||
|
||||
def test_multipointfield(self):
|
||||
class PointForm(forms.Form):
|
||||
p = forms.MultiPointField()
|
||||
|
||||
geom = self.geometries['multipoint']
|
||||
form = PointForm(data={'p': geom})
|
||||
self.assertTextarea(geom, form.as_p())
|
||||
self.assertMapWidget(form)
|
||||
self.assertFalse(PointForm().is_valid())
|
||||
|
||||
for invalid in [geo for key, geo in self.geometries.items() if key != 'multipoint']:
|
||||
self.assertFalse(PointForm(data={'p': invalid.wkt}).is_valid())
|
||||
|
||||
def test_linestringfield(self):
|
||||
class LineStringForm(forms.Form):
|
||||
l = forms.LineStringField()
|
||||
|
||||
geom = self.geometries['linestring']
|
||||
form = LineStringForm(data={'l': geom})
|
||||
self.assertTextarea(geom, form.as_p())
|
||||
self.assertMapWidget(form)
|
||||
self.assertFalse(LineStringForm().is_valid())
|
||||
|
||||
for invalid in [geo for key, geo in self.geometries.items() if key != 'linestring']:
|
||||
self.assertFalse(LineStringForm(data={'p': invalid.wkt}).is_valid())
|
||||
|
||||
def test_multilinestringfield(self):
|
||||
class LineStringForm(forms.Form):
|
||||
l = forms.MultiLineStringField()
|
||||
|
||||
geom = self.geometries['multilinestring']
|
||||
form = LineStringForm(data={'l': geom})
|
||||
self.assertTextarea(geom, form.as_p())
|
||||
self.assertMapWidget(form)
|
||||
self.assertFalse(LineStringForm().is_valid())
|
||||
|
||||
for invalid in [geo for key, geo in self.geometries.items() if key != 'multilinestring']:
|
||||
self.assertFalse(LineStringForm(data={'p': invalid.wkt}).is_valid())
|
||||
|
||||
def test_polygonfield(self):
|
||||
class PolygonForm(forms.Form):
|
||||
p = forms.PolygonField()
|
||||
|
||||
geom = self.geometries['polygon']
|
||||
form = PolygonForm(data={'p': geom})
|
||||
self.assertTextarea(geom, form.as_p())
|
||||
self.assertMapWidget(form)
|
||||
self.assertFalse(PolygonForm().is_valid())
|
||||
|
||||
for invalid in [geo for key, geo in self.geometries.items() if key != 'polygon']:
|
||||
self.assertFalse(PolygonForm(data={'p': invalid.wkt}).is_valid())
|
||||
|
||||
def test_multipolygonfield(self):
|
||||
class PolygonForm(forms.Form):
|
||||
p = forms.MultiPolygonField()
|
||||
|
||||
geom = self.geometries['multipolygon']
|
||||
form = PolygonForm(data={'p': geom})
|
||||
self.assertTextarea(geom, form.as_p())
|
||||
self.assertMapWidget(form)
|
||||
self.assertFalse(PolygonForm().is_valid())
|
||||
|
||||
for invalid in [geo for key, geo in self.geometries.items() if key != 'multipolygon']:
|
||||
self.assertFalse(PolygonForm(data={'p': invalid.wkt}).is_valid())
|
||||
|
||||
def test_geometrycollectionfield(self):
|
||||
class GeometryForm(forms.Form):
|
||||
g = forms.GeometryCollectionField()
|
||||
|
||||
geom = self.geometries['geometrycollection']
|
||||
form = GeometryForm(data={'g': geom})
|
||||
self.assertTextarea(geom, form.as_p())
|
||||
self.assertMapWidget(form)
|
||||
self.assertFalse(GeometryForm().is_valid())
|
||||
|
||||
for invalid in [geo for key, geo in self.geometries.items() if key != 'geometrycollection']:
|
||||
self.assertFalse(GeometryForm(data={'g': invalid.wkt}).is_valid())
|
||||
|
||||
|
||||
@skipUnless(HAS_GDAL, "OSMWidgetTest needs GDAL support")
|
||||
@skipUnlessDBFeature("gis_enabled")
|
||||
class OSMWidgetTest(SimpleTestCase):
|
||||
def setUp(self):
|
||||
self.geometries = {
|
||||
'point': GEOSGeometry("SRID=4326;POINT(9.052734375 42.451171875)"),
|
||||
}
|
||||
|
||||
def test_osm_widget(self):
|
||||
class PointForm(forms.Form):
|
||||
p = forms.PointField(widget=forms.OSMWidget)
|
||||
|
||||
geom = self.geometries['point']
|
||||
form = PointForm(data={'p': geom})
|
||||
rendered = form.as_p()
|
||||
|
||||
self.assertIn("OpenStreetMap (Mapnik)", rendered)
|
||||
self.assertIn("id: 'id_p',", rendered)
|
||||
|
||||
def test_default_lat_lon(self):
|
||||
class PointForm(forms.Form):
|
||||
p = forms.PointField(
|
||||
widget=forms.OSMWidget(attrs={
|
||||
'default_lon': 20, 'default_lat': 30
|
||||
}),
|
||||
)
|
||||
|
||||
form = PointForm()
|
||||
rendered = form.as_p()
|
||||
|
||||
self.assertIn("options['default_lon'] = 20;", rendered)
|
||||
self.assertIn("options['default_lat'] = 30;", rendered)
|
||||
if forms.OSMWidget.default_lon != 20:
|
||||
self.assertNotIn(
|
||||
"options['default_lon'] = %d;" % forms.OSMWidget.default_lon,
|
||||
rendered)
|
||||
if forms.OSMWidget.default_lat != 30:
|
||||
self.assertNotIn(
|
||||
"options['default_lat'] = %d;" % forms.OSMWidget.default_lat,
|
||||
rendered)
|
||||
|
||||
|
||||
@skipUnless(HAS_GDAL, "CustomGeometryWidgetTest needs GDAL support")
|
||||
@skipUnlessDBFeature("gis_enabled")
|
||||
class CustomGeometryWidgetTest(SimpleTestCase):
|
||||
|
||||
def test_custom_serialization_widget(self):
|
||||
class CustomGeometryWidget(forms.BaseGeometryWidget):
|
||||
template_name = 'gis/openlayers.html'
|
||||
deserialize_called = 0
|
||||
|
||||
def serialize(self, value):
|
||||
return value.json if value else ''
|
||||
|
||||
def deserialize(self, value):
|
||||
self.deserialize_called += 1
|
||||
return GEOSGeometry(value)
|
||||
|
||||
class PointForm(forms.Form):
|
||||
p = forms.PointField(widget=CustomGeometryWidget)
|
||||
|
||||
point = GEOSGeometry("SRID=4326;POINT(9.052734375 42.451171875)")
|
||||
form = PointForm(data={'p': point})
|
||||
self.assertIn(escape(point.json), form.as_p())
|
||||
|
||||
CustomGeometryWidget.called = 0
|
||||
widget = form.fields['p'].widget
|
||||
# Force deserialize use due to a string value
|
||||
self.assertIn(escape(point.json), widget.render('p', point.json))
|
||||
self.assertEqual(widget.deserialize_called, 1)
|
||||
|
||||
form = PointForm(data={'p': point.json})
|
||||
self.assertTrue(form.is_valid())
|
||||
# Ensure that resulting geometry has srid set
|
||||
self.assertEqual(form.cleaned_data['p'].srid, 4326)
|
||||
@@ -1,279 +0,0 @@
|
||||
"""
|
||||
Distance and Area objects to allow for sensible and convenient calculation
|
||||
and conversions. Here are some tests.
|
||||
"""
|
||||
|
||||
import unittest
|
||||
|
||||
from django.contrib.gis.measure import A, D, Area, Distance
|
||||
|
||||
|
||||
class DistanceTest(unittest.TestCase):
|
||||
"Testing the Distance object"
|
||||
|
||||
def testInit(self):
|
||||
"Testing initialization from valid units"
|
||||
d = Distance(m=100)
|
||||
self.assertEqual(d.m, 100)
|
||||
|
||||
d1, d2, d3 = D(m=100), D(meter=100), D(metre=100)
|
||||
for d in (d1, d2, d3):
|
||||
self.assertEqual(d.m, 100)
|
||||
|
||||
d = D(nm=100)
|
||||
self.assertEqual(d.m, 185200)
|
||||
|
||||
y1, y2, y3 = D(yd=100), D(yard=100), D(Yard=100)
|
||||
for d in (y1, y2, y3):
|
||||
self.assertEqual(d.yd, 100)
|
||||
|
||||
mm1, mm2 = D(millimeter=1000), D(MiLLiMeTeR=1000)
|
||||
for d in (mm1, mm2):
|
||||
self.assertEqual(d.m, 1.0)
|
||||
self.assertEqual(d.mm, 1000.0)
|
||||
|
||||
def testInitInvalid(self):
|
||||
"Testing initialization from invalid units"
|
||||
self.assertRaises(AttributeError, D, banana=100)
|
||||
|
||||
def testAccess(self):
|
||||
"Testing access in different units"
|
||||
d = D(m=100)
|
||||
self.assertEqual(d.km, 0.1)
|
||||
self.assertAlmostEqual(d.ft, 328.084, 3)
|
||||
|
||||
def testAccessInvalid(self):
|
||||
"Testing access in invalid units"
|
||||
d = D(m=100)
|
||||
self.assertFalse(hasattr(d, 'banana'))
|
||||
|
||||
def testAddition(self):
|
||||
"Test addition & subtraction"
|
||||
d1 = D(m=100)
|
||||
d2 = D(m=200)
|
||||
|
||||
d3 = d1 + d2
|
||||
self.assertEqual(d3.m, 300)
|
||||
d3 += d1
|
||||
self.assertEqual(d3.m, 400)
|
||||
|
||||
d4 = d1 - d2
|
||||
self.assertEqual(d4.m, -100)
|
||||
d4 -= d1
|
||||
self.assertEqual(d4.m, -200)
|
||||
|
||||
with self.assertRaises(TypeError):
|
||||
d1 + 1
|
||||
|
||||
with self.assertRaises(TypeError):
|
||||
d1 - 1
|
||||
|
||||
with self.assertRaises(TypeError):
|
||||
d1 += 1
|
||||
|
||||
with self.assertRaises(TypeError):
|
||||
d1 -= 1
|
||||
|
||||
def testMultiplication(self):
|
||||
"Test multiplication & division"
|
||||
d1 = D(m=100)
|
||||
|
||||
d3 = d1 * 2
|
||||
self.assertEqual(d3.m, 200)
|
||||
d3 = 2 * d1
|
||||
self.assertEqual(d3.m, 200)
|
||||
d3 *= 5
|
||||
self.assertEqual(d3.m, 1000)
|
||||
|
||||
d4 = d1 / 2
|
||||
self.assertEqual(d4.m, 50)
|
||||
d4 /= 5
|
||||
self.assertEqual(d4.m, 10)
|
||||
d5 = d1 / D(m=2)
|
||||
self.assertEqual(d5, 50)
|
||||
|
||||
a5 = d1 * D(m=10)
|
||||
self.assertIsInstance(a5, Area)
|
||||
self.assertEqual(a5.sq_m, 100 * 10)
|
||||
|
||||
with self.assertRaises(TypeError):
|
||||
d1 *= D(m=1)
|
||||
|
||||
with self.assertRaises(TypeError):
|
||||
d1 /= D(m=1)
|
||||
|
||||
def testUnitConversions(self):
|
||||
"Testing default units during maths"
|
||||
d1 = D(m=100)
|
||||
d2 = D(km=1)
|
||||
|
||||
d3 = d1 + d2
|
||||
self.assertEqual(d3._default_unit, 'm')
|
||||
d4 = d2 + d1
|
||||
self.assertEqual(d4._default_unit, 'km')
|
||||
d5 = d1 * 2
|
||||
self.assertEqual(d5._default_unit, 'm')
|
||||
d6 = d1 / 2
|
||||
self.assertEqual(d6._default_unit, 'm')
|
||||
|
||||
def testComparisons(self):
|
||||
"Testing comparisons"
|
||||
d1 = D(m=100)
|
||||
d2 = D(km=1)
|
||||
d3 = D(km=0)
|
||||
|
||||
self.assertGreater(d2, d1)
|
||||
self.assertEqual(d1, d1)
|
||||
self.assertLess(d1, d2)
|
||||
self.assertFalse(d3)
|
||||
|
||||
def testUnitsStr(self):
|
||||
"Testing conversion to strings"
|
||||
d1 = D(m=100)
|
||||
d2 = D(km=3.5)
|
||||
|
||||
self.assertEqual(str(d1), '100.0 m')
|
||||
self.assertEqual(str(d2), '3.5 km')
|
||||
self.assertEqual(repr(d1), 'Distance(m=100.0)')
|
||||
self.assertEqual(repr(d2), 'Distance(km=3.5)')
|
||||
|
||||
def testUnitAttName(self):
|
||||
"Testing the `unit_attname` class method"
|
||||
unit_tuple = [('Yard', 'yd'), ('Nautical Mile', 'nm'), ('German legal metre', 'german_m'),
|
||||
('Indian yard', 'indian_yd'), ('Chain (Sears)', 'chain_sears'), ('Chain', 'chain')]
|
||||
for nm, att in unit_tuple:
|
||||
self.assertEqual(att, D.unit_attname(nm))
|
||||
|
||||
|
||||
class AreaTest(unittest.TestCase):
|
||||
"Testing the Area object"
|
||||
|
||||
def testInit(self):
|
||||
"Testing initialization from valid units"
|
||||
a = Area(sq_m=100)
|
||||
self.assertEqual(a.sq_m, 100)
|
||||
|
||||
a = A(sq_m=100)
|
||||
self.assertEqual(a.sq_m, 100)
|
||||
|
||||
a = A(sq_mi=100)
|
||||
self.assertEqual(a.sq_m, 258998811.0336)
|
||||
|
||||
def testInitInvaliA(self):
|
||||
"Testing initialization from invalid units"
|
||||
self.assertRaises(AttributeError, A, banana=100)
|
||||
|
||||
def testAccess(self):
|
||||
"Testing access in different units"
|
||||
a = A(sq_m=100)
|
||||
self.assertEqual(a.sq_km, 0.0001)
|
||||
self.assertAlmostEqual(a.sq_ft, 1076.391, 3)
|
||||
|
||||
def testAccessInvaliA(self):
|
||||
"Testing access in invalid units"
|
||||
a = A(sq_m=100)
|
||||
self.assertFalse(hasattr(a, 'banana'))
|
||||
|
||||
def testAddition(self):
|
||||
"Test addition & subtraction"
|
||||
a1 = A(sq_m=100)
|
||||
a2 = A(sq_m=200)
|
||||
|
||||
a3 = a1 + a2
|
||||
self.assertEqual(a3.sq_m, 300)
|
||||
a3 += a1
|
||||
self.assertEqual(a3.sq_m, 400)
|
||||
|
||||
a4 = a1 - a2
|
||||
self.assertEqual(a4.sq_m, -100)
|
||||
a4 -= a1
|
||||
self.assertEqual(a4.sq_m, -200)
|
||||
|
||||
with self.assertRaises(TypeError):
|
||||
a1 + 1
|
||||
|
||||
with self.assertRaises(TypeError):
|
||||
a1 - 1
|
||||
|
||||
with self.assertRaises(TypeError):
|
||||
a1 += 1
|
||||
|
||||
with self.assertRaises(TypeError):
|
||||
a1 -= 1
|
||||
|
||||
def testMultiplication(self):
|
||||
"Test multiplication & division"
|
||||
a1 = A(sq_m=100)
|
||||
|
||||
a3 = a1 * 2
|
||||
self.assertEqual(a3.sq_m, 200)
|
||||
a3 = 2 * a1
|
||||
self.assertEqual(a3.sq_m, 200)
|
||||
a3 *= 5
|
||||
self.assertEqual(a3.sq_m, 1000)
|
||||
|
||||
a4 = a1 / 2
|
||||
self.assertEqual(a4.sq_m, 50)
|
||||
a4 /= 5
|
||||
self.assertEqual(a4.sq_m, 10)
|
||||
|
||||
with self.assertRaises(TypeError):
|
||||
a1 * A(sq_m=1)
|
||||
|
||||
with self.assertRaises(TypeError):
|
||||
a1 *= A(sq_m=1)
|
||||
|
||||
with self.assertRaises(TypeError):
|
||||
a1 / A(sq_m=1)
|
||||
|
||||
with self.assertRaises(TypeError):
|
||||
a1 /= A(sq_m=1)
|
||||
|
||||
def testUnitConversions(self):
|
||||
"Testing default units during maths"
|
||||
a1 = A(sq_m=100)
|
||||
a2 = A(sq_km=1)
|
||||
|
||||
a3 = a1 + a2
|
||||
self.assertEqual(a3._default_unit, 'sq_m')
|
||||
a4 = a2 + a1
|
||||
self.assertEqual(a4._default_unit, 'sq_km')
|
||||
a5 = a1 * 2
|
||||
self.assertEqual(a5._default_unit, 'sq_m')
|
||||
a6 = a1 / 2
|
||||
self.assertEqual(a6._default_unit, 'sq_m')
|
||||
|
||||
def testComparisons(self):
|
||||
"Testing comparisons"
|
||||
a1 = A(sq_m=100)
|
||||
a2 = A(sq_km=1)
|
||||
a3 = A(sq_km=0)
|
||||
|
||||
self.assertGreater(a2, a1)
|
||||
self.assertEqual(a1, a1)
|
||||
self.assertLess(a1, a2)
|
||||
self.assertFalse(a3)
|
||||
|
||||
def testUnitsStr(self):
|
||||
"Testing conversion to strings"
|
||||
a1 = A(sq_m=100)
|
||||
a2 = A(sq_km=3.5)
|
||||
|
||||
self.assertEqual(str(a1), '100.0 sq_m')
|
||||
self.assertEqual(str(a2), '3.5 sq_km')
|
||||
self.assertEqual(repr(a1), 'Area(sq_m=100.0)')
|
||||
self.assertEqual(repr(a2), 'Area(sq_km=3.5)')
|
||||
|
||||
|
||||
def suite():
|
||||
s = unittest.TestSuite()
|
||||
s.addTest(unittest.makeSuite(DistanceTest))
|
||||
s.addTest(unittest.makeSuite(AreaTest))
|
||||
return s
|
||||
|
||||
|
||||
def run(verbosity=2):
|
||||
unittest.TextTestRunner(verbosity=verbosity).run(suite())
|
||||
|
||||
if __name__ == "__main__":
|
||||
run()
|
||||
@@ -1,123 +0,0 @@
|
||||
import unittest
|
||||
|
||||
from django.contrib.gis.gdal import HAS_GDAL
|
||||
from django.contrib.gis.tests.utils import (
|
||||
SpatialRefSys, oracle, postgis, spatialite,
|
||||
)
|
||||
from django.db import connection
|
||||
from django.test import skipUnlessDBFeature
|
||||
from django.utils import six
|
||||
|
||||
test_srs = ({
|
||||
'srid': 4326,
|
||||
'auth_name': ('EPSG', True),
|
||||
'auth_srid': 4326,
|
||||
# Only the beginning, because there are differences depending on installed libs
|
||||
'srtext': 'GEOGCS["WGS 84",DATUM["WGS_1984",SPHEROID["WGS 84"',
|
||||
# +ellps=WGS84 has been removed in the 4326 proj string in proj-4.8
|
||||
'proj4_re': r'\+proj=longlat (\+ellps=WGS84 )?(\+datum=WGS84 |\+towgs84=0,0,0,0,0,0,0 )\+no_defs ',
|
||||
'spheroid': 'WGS 84', 'name': 'WGS 84',
|
||||
'geographic': True, 'projected': False, 'spatialite': True,
|
||||
# From proj's "cs2cs -le" and Wikipedia (semi-minor only)
|
||||
'ellipsoid': (6378137.0, 6356752.3, 298.257223563),
|
||||
'eprec': (1, 1, 9),
|
||||
}, {
|
||||
'srid': 32140,
|
||||
'auth_name': ('EPSG', False),
|
||||
'auth_srid': 32140,
|
||||
'srtext': (
|
||||
'PROJCS["NAD83 / Texas South Central",GEOGCS["NAD83",'
|
||||
'DATUM["North_American_Datum_1983",SPHEROID["GRS 1980"'
|
||||
),
|
||||
'proj4_re': r'\+proj=lcc \+lat_1=30.28333333333333 \+lat_2=28.38333333333333 \+lat_0=27.83333333333333 '
|
||||
r'\+lon_0=-99 \+x_0=600000 \+y_0=4000000 (\+ellps=GRS80 )?'
|
||||
r'(\+datum=NAD83 |\+towgs84=0,0,0,0,0,0,0 )?\+units=m \+no_defs ',
|
||||
'spheroid': 'GRS 1980', 'name': 'NAD83 / Texas South Central',
|
||||
'geographic': False, 'projected': True, 'spatialite': False,
|
||||
# From proj's "cs2cs -le" and Wikipedia (semi-minor only)
|
||||
'ellipsoid': (6378137.0, 6356752.31414, 298.257222101),
|
||||
'eprec': (1, 5, 10),
|
||||
})
|
||||
|
||||
|
||||
@unittest.skipUnless(HAS_GDAL, "SpatialRefSysTest needs gdal support")
|
||||
@skipUnlessDBFeature("has_spatialrefsys_table")
|
||||
class SpatialRefSysTest(unittest.TestCase):
|
||||
|
||||
def test_retrieve(self):
|
||||
"""
|
||||
Test retrieval of SpatialRefSys model objects.
|
||||
"""
|
||||
for sd in test_srs:
|
||||
srs = SpatialRefSys.objects.get(srid=sd['srid'])
|
||||
self.assertEqual(sd['srid'], srs.srid)
|
||||
|
||||
# Some of the authority names are borked on Oracle, e.g., SRID=32140.
|
||||
# also, Oracle Spatial seems to add extraneous info to fields, hence the
|
||||
# the testing with the 'startswith' flag.
|
||||
auth_name, oracle_flag = sd['auth_name']
|
||||
if postgis or (oracle and oracle_flag):
|
||||
self.assertEqual(True, srs.auth_name.startswith(auth_name))
|
||||
|
||||
self.assertEqual(sd['auth_srid'], srs.auth_srid)
|
||||
|
||||
# No proj.4 and different srtext on oracle backends :(
|
||||
if postgis:
|
||||
self.assertTrue(srs.wkt.startswith(sd['srtext']))
|
||||
six.assertRegex(self, srs.proj4text, sd['proj4_re'])
|
||||
|
||||
def test_osr(self):
|
||||
"""
|
||||
Test getting OSR objects from SpatialRefSys model objects.
|
||||
"""
|
||||
for sd in test_srs:
|
||||
sr = SpatialRefSys.objects.get(srid=sd['srid'])
|
||||
self.assertEqual(True, sr.spheroid.startswith(sd['spheroid']))
|
||||
self.assertEqual(sd['geographic'], sr.geographic)
|
||||
self.assertEqual(sd['projected'], sr.projected)
|
||||
|
||||
if not (spatialite and not sd['spatialite']):
|
||||
# Can't get 'NAD83 / Texas South Central' from PROJ.4 string
|
||||
# on SpatiaLite
|
||||
self.assertEqual(True, sr.name.startswith(sd['name']))
|
||||
|
||||
# Testing the SpatialReference object directly.
|
||||
if postgis or spatialite:
|
||||
srs = sr.srs
|
||||
six.assertRegex(self, srs.proj4, sd['proj4_re'])
|
||||
# No `srtext` field in the `spatial_ref_sys` table in SpatiaLite < 4
|
||||
if not spatialite or connection.ops.spatial_version[0] >= 4:
|
||||
self.assertTrue(srs.wkt.startswith(sd['srtext']))
|
||||
|
||||
def test_ellipsoid(self):
|
||||
"""
|
||||
Test the ellipsoid property.
|
||||
"""
|
||||
for sd in test_srs:
|
||||
# Getting the ellipsoid and precision parameters.
|
||||
ellps1 = sd['ellipsoid']
|
||||
prec = sd['eprec']
|
||||
|
||||
# Getting our spatial reference and its ellipsoid
|
||||
srs = SpatialRefSys.objects.get(srid=sd['srid'])
|
||||
ellps2 = srs.ellipsoid
|
||||
|
||||
for i in range(3):
|
||||
self.assertAlmostEqual(ellps1[i], ellps2[i], prec[i])
|
||||
|
||||
@skipUnlessDBFeature('supports_add_srs_entry')
|
||||
def test_add_entry(self):
|
||||
"""
|
||||
Test adding a new entry in the SpatialRefSys model using the
|
||||
add_srs_entry utility.
|
||||
"""
|
||||
from django.contrib.gis.utils import add_srs_entry
|
||||
|
||||
add_srs_entry(3857)
|
||||
self.assertTrue(
|
||||
SpatialRefSys.objects.filter(srid=3857).exists()
|
||||
)
|
||||
srs = SpatialRefSys.objects.get(srid=3857)
|
||||
self.assertTrue(
|
||||
SpatialRefSys.get_spheroid(srs.wkt).startswith('SPHEROID[')
|
||||
)
|
||||
@@ -1,92 +0,0 @@
|
||||
import sys
|
||||
import unittest
|
||||
|
||||
from django.core.exceptions import ImproperlyConfigured
|
||||
from django.db import ProgrammingError
|
||||
from django.utils import six
|
||||
|
||||
try:
|
||||
from django.contrib.gis.db.backends.postgis.operations import PostGISOperations
|
||||
HAS_POSTGRES = True
|
||||
except ImportError:
|
||||
HAS_POSTGRES = False
|
||||
except ImproperlyConfigured as e:
|
||||
# If psycopg is installed but not geos, the import path hits
|
||||
# django.contrib.gis.geometry.backend which will "helpfully" convert
|
||||
# an ImportError into an ImproperlyConfigured.
|
||||
# Here, we make sure we're only catching this specific case and not another
|
||||
# ImproperlyConfigured one.
|
||||
if e.args and e.args[0].startswith('Could not import user-defined GEOMETRY_BACKEND'):
|
||||
HAS_POSTGRES = False
|
||||
else:
|
||||
six.reraise(*sys.exc_info())
|
||||
|
||||
|
||||
if HAS_POSTGRES:
|
||||
class FakeConnection(object):
|
||||
def __init__(self):
|
||||
self.settings_dict = {
|
||||
'NAME': 'test',
|
||||
}
|
||||
|
||||
class FakePostGISOperations(PostGISOperations):
|
||||
def __init__(self, version=None):
|
||||
self.version = version
|
||||
self.connection = FakeConnection()
|
||||
|
||||
def _get_postgis_func(self, func):
|
||||
if func == 'postgis_lib_version':
|
||||
if self.version is None:
|
||||
raise ProgrammingError
|
||||
else:
|
||||
return self.version
|
||||
else:
|
||||
raise NotImplementedError('This function was not expected to be called')
|
||||
|
||||
|
||||
@unittest.skipUnless(HAS_POSTGRES, "The psycopg2 driver is needed for these tests")
|
||||
class TestPostgisVersionCheck(unittest.TestCase):
|
||||
"""
|
||||
Tests that the postgis version check parses correctly the version numbers
|
||||
"""
|
||||
|
||||
def test_get_version(self):
|
||||
expect = '1.0.0'
|
||||
ops = FakePostGISOperations(expect)
|
||||
actual = ops.postgis_lib_version()
|
||||
self.assertEqual(expect, actual)
|
||||
|
||||
def test_version_classic_tuple(self):
|
||||
expect = ('1.2.3', 1, 2, 3)
|
||||
ops = FakePostGISOperations(expect[0])
|
||||
actual = ops.postgis_version_tuple()
|
||||
self.assertEqual(expect, actual)
|
||||
|
||||
def test_version_dev_tuple(self):
|
||||
expect = ('1.2.3dev', 1, 2, 3)
|
||||
ops = FakePostGISOperations(expect[0])
|
||||
actual = ops.postgis_version_tuple()
|
||||
self.assertEqual(expect, actual)
|
||||
|
||||
def test_valid_version_numbers(self):
|
||||
versions = [
|
||||
('1.3.0', 1, 3, 0),
|
||||
('2.1.1', 2, 1, 1),
|
||||
('2.2.0dev', 2, 2, 0),
|
||||
]
|
||||
|
||||
for version in versions:
|
||||
ops = FakePostGISOperations(version[0])
|
||||
actual = ops.spatial_version
|
||||
self.assertEqual(version[1:], actual)
|
||||
|
||||
def test_invalid_version_numbers(self):
|
||||
versions = ['nope', '123']
|
||||
|
||||
for version in versions:
|
||||
ops = FakePostGISOperations(version)
|
||||
self.assertRaises(Exception, lambda: ops.spatial_version)
|
||||
|
||||
def test_no_version_number(self):
|
||||
ops = FakePostGISOperations()
|
||||
self.assertRaises(ImproperlyConfigured, lambda: ops.spatial_version)
|
||||
@@ -1,41 +0,0 @@
|
||||
from unittest import skip
|
||||
|
||||
from django.conf import settings
|
||||
from django.db import DEFAULT_DB_ALIAS
|
||||
|
||||
|
||||
def no_backend(test_func, backend):
|
||||
"Use this decorator to disable test on specified backend."
|
||||
if settings.DATABASES[DEFAULT_DB_ALIAS]['ENGINE'].rsplit('.')[-1] == backend:
|
||||
@skip("This test is skipped on '%s' backend" % backend)
|
||||
def inner():
|
||||
pass
|
||||
return inner
|
||||
else:
|
||||
return test_func
|
||||
|
||||
|
||||
# Decorators to disable entire test functions for specific
|
||||
# spatial backends.
|
||||
def no_oracle(func):
|
||||
return no_backend(func, 'oracle')
|
||||
|
||||
|
||||
# Shortcut booleans to omit only portions of tests.
|
||||
_default_db = settings.DATABASES[DEFAULT_DB_ALIAS]['ENGINE'].rsplit('.')[-1]
|
||||
oracle = _default_db == 'oracle'
|
||||
postgis = _default_db == 'postgis'
|
||||
mysql = _default_db == 'mysql'
|
||||
spatialite = _default_db == 'spatialite'
|
||||
|
||||
# MySQL spatial indices can't handle NULL geometries.
|
||||
gisfield_may_be_null = not mysql
|
||||
|
||||
if oracle and 'gis' in settings.DATABASES[DEFAULT_DB_ALIAS]['ENGINE']:
|
||||
from django.contrib.gis.db.backends.oracle.models import OracleSpatialRefSys as SpatialRefSys
|
||||
elif postgis:
|
||||
from django.contrib.gis.db.backends.postgis.models import PostGISSpatialRefSys as SpatialRefSys
|
||||
elif spatialite:
|
||||
from django.contrib.gis.db.backends.spatialite.models import SpatialiteSpatialRefSys as SpatialRefSys
|
||||
else:
|
||||
SpatialRefSys = None
|
||||
Reference in New Issue
Block a user