| 1 |
from django.contrib.gis.db.models.functions import ( |
| 2 |
Area, |
| 3 |
Distance, |
| 4 |
Length, |
| 5 |
Perimeter, |
| 6 |
Transform, |
| 7 |
Union, |
| 8 |
) |
| 9 |
from django.contrib.gis.geos import GEOSGeometry, LineString, Point |
| 10 |
from django.contrib.gis.measure import D # alias for Distance |
| 11 |
from django.db import NotSupportedError, connection |
| 12 |
from django.db.models import ( |
| 13 |
Case, |
| 14 |
Count, |
| 15 |
Exists, |
| 16 |
F, |
| 17 |
IntegerField, |
| 18 |
OuterRef, |
| 19 |
Q, |
| 20 |
Value, |
| 21 |
When, |
| 22 |
) |
| 23 |
from django.test import TestCase, skipIfDBFeature, skipUnlessDBFeature |
| 24 |
|
| 25 |
from ..utils import FuncTestMixin |
| 26 |
from .models import ( |
| 27 |
AustraliaCity, |
| 28 |
CensusZipcode, |
| 29 |
Interstate, |
| 30 |
SouthTexasCity, |
| 31 |
SouthTexasCityFt, |
| 32 |
SouthTexasInterstate, |
| 33 |
SouthTexasZipcode, |
| 34 |
) |
| 35 |
|
| 36 |
|
| 37 |
class DistanceTest(TestCase): |
| 38 |
fixtures = ["initial"] |
| 39 |
|
| 40 |
def setUp(self): |
| 41 |
# A point we are testing distances with -- using a WGS84 |
| 42 |
# coordinate that'll be implicitly transformed to that to |
| 43 |
# the coordinate system of the field, EPSG:32140 (Texas South Central |
| 44 |
# w/units in meters) |
| 45 |
self.stx_pnt = GEOSGeometry( |
| 46 |
"POINT (-95.370401017314293 29.704867409475465)", 4326 |
| 47 |
) |
| 48 |
# Another one for Australia |
| 49 |
self.au_pnt = GEOSGeometry("POINT (150.791 -34.4919)", 4326) |
| 50 |
|
| 51 |
def get_names(self, qs): |
| 52 |
cities = [c.name for c in qs] |
| 53 |
cities.sort() |
| 54 |
return cities |
| 55 |
|
| 56 |
def test_init(self): |
| 57 |
""" |
| 58 |
Test initialization of distance models. |
| 59 |
""" |
| 60 |
self.assertEqual(9, SouthTexasCity.objects.count()) |
| 61 |
self.assertEqual(9, SouthTexasCityFt.objects.count()) |
| 62 |
self.assertEqual(11, AustraliaCity.objects.count()) |
| 63 |
self.assertEqual(4, SouthTexasZipcode.objects.count()) |
| 64 |
self.assertEqual(4, CensusZipcode.objects.count()) |
| 65 |
self.assertEqual(1, Interstate.objects.count()) |
| 66 |
self.assertEqual(1, SouthTexasInterstate.objects.count()) |
| 67 |
|
| 68 |
@skipUnlessDBFeature("supports_dwithin_lookup") |
| 69 |
def test_dwithin(self): |
| 70 |
""" |
| 71 |
Test the `dwithin` lookup type. |
| 72 |
""" |
| 73 |
# Distances -- all should be equal (except for the |
| 74 |
# degree/meter pair in au_cities, that's somewhat |
| 75 |
# approximate). |
| 76 |
tx_dists = [(7000, 22965.83), D(km=7), D(mi=4.349)] |
| 77 |
au_dists = [(0.5, 32000), D(km=32), D(mi=19.884)] |
| 78 |
|
| 79 |
# Expected cities for Australia and Texas. |
| 80 |
tx_cities = ["Downtown Houston", "Southside Place"] |
| 81 |
au_cities = ["Mittagong", "Shellharbour", "Thirroul", "Wollongong"] |
| 82 |
|
| 83 |
# Performing distance queries on two projected coordinate systems one |
| 84 |
# with units in meters and the other in units of U.S. survey feet. |
| 85 |
for dist in tx_dists: |
| 86 |
if isinstance(dist, tuple): |
| 87 |
dist1, dist2 = dist |
| 88 |
else: |
| 89 |
dist1 = dist2 = dist |
| 90 |
qs1 = SouthTexasCity.objects.filter(point__dwithin=(self.stx_pnt, dist1)) |
| 91 |
qs2 = SouthTexasCityFt.objects.filter(point__dwithin=(self.stx_pnt, dist2)) |
| 92 |
for qs in qs1, qs2: |
| 93 |
with self.subTest(dist=dist, qs=qs): |
| 94 |
self.assertEqual(tx_cities, self.get_names(qs)) |
| 95 |
|
| 96 |
# With a complex geometry expression |
| 97 |
self.assertFalse( |
| 98 |
SouthTexasCity.objects.exclude(point__dwithin=(Union("point", "point"), 0)) |
| 99 |
) |
| 100 |
|
| 101 |
# Now performing the `dwithin` queries on a geodetic coordinate system. |
| 102 |
for dist in au_dists: |
| 103 |
with self.subTest(dist=dist): |
| 104 |
type_error = isinstance(dist, D) and not connection.ops.oracle |
| 105 |
if isinstance(dist, tuple): |
| 106 |
if connection.ops.oracle or connection.ops.spatialite: |
| 107 |
# Result in meters |
| 108 |
dist = dist[1] |
| 109 |
else: |
| 110 |
# Result in units of the field |
| 111 |
dist = dist[0] |
| 112 |
|
| 113 |
# Creating the query set. |
| 114 |
qs = AustraliaCity.objects.order_by("name") |
| 115 |
if type_error: |
| 116 |
# A ValueError should be raised on PostGIS when trying to |
| 117 |
# pass Distance objects into a DWithin query using a |
| 118 |
# geodetic field. |
| 119 |
with self.assertRaises(ValueError): |
| 120 |
AustraliaCity.objects.filter( |
| 121 |
point__dwithin=(self.au_pnt, dist) |
| 122 |
).count() |
| 123 |
else: |
| 124 |
self.assertEqual( |
| 125 |
au_cities, |
| 126 |
self.get_names(qs.filter(point__dwithin=(self.au_pnt, dist))), |
| 127 |
) |
| 128 |
|
| 129 |
@skipUnlessDBFeature("supports_distances_lookups") |
| 130 |
def test_distance_lookups(self): |
| 131 |
# Retrieving the cities within a 20km 'donut' w/a 7km radius 'hole' |
| 132 |
# (thus, Houston and Southside place will be excluded as tested in |
| 133 |
# the `test02_dwithin` above). |
| 134 |
for model in [SouthTexasCity, SouthTexasCityFt]: |
| 135 |
stx_pnt = self.stx_pnt.transform( |
| 136 |
model._meta.get_field("point").srid, clone=True |
| 137 |
) |
| 138 |
qs = model.objects.filter(point__distance_gte=(stx_pnt, D(km=7))).filter( |
| 139 |
point__distance_lte=(stx_pnt, D(km=20)), |
| 140 |
) |
| 141 |
cities = self.get_names(qs) |
| 142 |
self.assertEqual(cities, ["Bellaire", "Pearland", "West University Place"]) |
| 143 |
|
| 144 |
# Doing a distance query using Polygons instead of a Point. |
| 145 |
z = SouthTexasZipcode.objects.get(name="77005") |
| 146 |
qs = SouthTexasZipcode.objects.exclude(name="77005").filter( |
| 147 |
poly__distance_lte=(z.poly, D(m=275)) |
| 148 |
) |
| 149 |
self.assertEqual(["77025", "77401"], self.get_names(qs)) |
| 150 |
# If we add a little more distance 77002 should be included. |
| 151 |
qs = SouthTexasZipcode.objects.exclude(name="77005").filter( |
| 152 |
poly__distance_lte=(z.poly, D(m=300)) |
| 153 |
) |
| 154 |
self.assertEqual(["77002", "77025", "77401"], self.get_names(qs)) |
| 155 |
|
| 156 |
@skipUnlessDBFeature("supports_distances_lookups", "supports_distance_geodetic") |
| 157 |
def test_geodetic_distance_lookups(self): |
| 158 |
""" |
| 159 |
Test distance lookups on geodetic coordinate systems. |
| 160 |
""" |
| 161 |
# Line is from Canberra to Sydney. Query is for all other cities within |
| 162 |
# a 100km of that line (which should exclude only Hobart & Adelaide). |
| 163 |
line = GEOSGeometry("LINESTRING(144.9630 -37.8143,151.2607 -33.8870)", 4326) |
| 164 |
dist_qs = AustraliaCity.objects.filter(point__distance_lte=(line, D(km=100))) |
| 165 |
expected_cities = [ |
| 166 |
"Batemans Bay", |
| 167 |
"Canberra", |
| 168 |
"Hillsdale", |
| 169 |
"Melbourne", |
| 170 |
"Mittagong", |
| 171 |
"Shellharbour", |
| 172 |
"Sydney", |
| 173 |
"Thirroul", |
| 174 |
"Wollongong", |
| 175 |
] |
| 176 |
if connection.ops.spatialite: |
| 177 |
# SpatiaLite is less accurate and returns 102.8km for Batemans Bay. |
| 178 |
expected_cities.pop(0) |
| 179 |
self.assertEqual(expected_cities, self.get_names(dist_qs)) |
| 180 |
|
| 181 |
msg = "2, 3, or 4-element tuple required for 'distance_lte' lookup." |
| 182 |
with self.assertRaisesMessage(ValueError, msg): # Too many params. |
| 183 |
len( |
| 184 |
AustraliaCity.objects.filter( |
| 185 |
point__distance_lte=( |
| 186 |
"POINT(5 23)", |
| 187 |
D(km=100), |
| 188 |
"spheroid", |
| 189 |
"4", |
| 190 |
None, |
| 191 |
) |
| 192 |
) |
| 193 |
) |
| 194 |
|
| 195 |
with self.assertRaisesMessage(ValueError, msg): # Too few params. |
| 196 |
len(AustraliaCity.objects.filter(point__distance_lte=("POINT(5 23)",))) |
| 197 |
|
| 198 |
msg = "For 4-element tuples the last argument must be the 'spheroid' directive." |
| 199 |
with self.assertRaisesMessage(ValueError, msg): |
| 200 |
len( |
| 201 |
AustraliaCity.objects.filter( |
| 202 |
point__distance_lte=("POINT(5 23)", D(km=100), "spheroid", "4") |
| 203 |
) |
| 204 |
) |
| 205 |
|
| 206 |
# Getting all cities w/in 550 miles of Hobart. |
| 207 |
hobart = AustraliaCity.objects.get(name="Hobart") |
| 208 |
qs = AustraliaCity.objects.exclude(name="Hobart").filter( |
| 209 |
point__distance_lte=(hobart.point, D(mi=550)) |
| 210 |
) |
| 211 |
cities = self.get_names(qs) |
| 212 |
self.assertEqual(cities, ["Batemans Bay", "Canberra", "Melbourne"]) |
| 213 |
|
| 214 |
# Cities that are either really close or really far from Wollongong -- |
| 215 |
# and using different units of distance. |
| 216 |
wollongong = AustraliaCity.objects.get(name="Wollongong") |
| 217 |
d1, d2 = D(yd=19500), D(nm=400) # Yards (~17km) & Nautical miles. |
| 218 |
|
| 219 |
# Normal geodetic distance lookup (uses `distance_sphere` on PostGIS. |
| 220 |
gq1 = Q(point__distance_lte=(wollongong.point, d1)) |
| 221 |
gq2 = Q(point__distance_gte=(wollongong.point, d2)) |
| 222 |
qs1 = AustraliaCity.objects.exclude(name="Wollongong").filter(gq1 | gq2) |
| 223 |
|
| 224 |
# Geodetic distance lookup but telling GeoDjango to use `distance_spheroid` |
| 225 |
# instead (we should get the same results b/c accuracy variance won't matter |
| 226 |
# in this test case). |
| 227 |
querysets = [qs1] |
| 228 |
if connection.features.has_DistanceSpheroid_function: |
| 229 |
gq3 = Q(point__distance_lte=(wollongong.point, d1, "spheroid")) |
| 230 |
gq4 = Q(point__distance_gte=(wollongong.point, d2, "spheroid")) |
| 231 |
qs2 = AustraliaCity.objects.exclude(name="Wollongong").filter(gq3 | gq4) |
| 232 |
querysets.append(qs2) |
| 233 |
|
| 234 |
for qs in querysets: |
| 235 |
cities = self.get_names(qs) |
| 236 |
self.assertEqual(cities, ["Adelaide", "Hobart", "Shellharbour", "Thirroul"]) |
| 237 |
|
| 238 |
@skipUnlessDBFeature("supports_distances_lookups") |
| 239 |
def test_distance_lookups_with_expression_rhs(self): |
| 240 |
stx_pnt = self.stx_pnt.transform( |
| 241 |
SouthTexasCity._meta.get_field("point").srid, clone=True |
| 242 |
) |
| 243 |
qs = SouthTexasCity.objects.filter( |
| 244 |
point__distance_lte=(stx_pnt, F("radius")), |
| 245 |
).order_by("name") |
| 246 |
self.assertEqual( |
| 247 |
self.get_names(qs), |
| 248 |
[ |
| 249 |
"Bellaire", |
| 250 |
"Downtown Houston", |
| 251 |
"Southside Place", |
| 252 |
"West University Place", |
| 253 |
], |
| 254 |
) |
| 255 |
|
| 256 |
# With a combined expression |
| 257 |
qs = SouthTexasCity.objects.filter( |
| 258 |
point__distance_lte=(stx_pnt, F("radius") * 2), |
| 259 |
).order_by("name") |
| 260 |
self.assertEqual(len(qs), 5) |
| 261 |
self.assertIn("Pearland", self.get_names(qs)) |
| 262 |
|
| 263 |
# With spheroid param |
| 264 |
if connection.features.supports_distance_geodetic: |
| 265 |
hobart = AustraliaCity.objects.get(name="Hobart") |
| 266 |
AustraliaCity.objects.update(ref_point=hobart.point) |
| 267 |
for ref_point in [hobart.point, F("ref_point")]: |
| 268 |
qs = AustraliaCity.objects.filter( |
| 269 |
point__distance_lte=(ref_point, F("radius") * 70, "spheroid"), |
| 270 |
).order_by("name") |
| 271 |
self.assertEqual( |
| 272 |
self.get_names(qs), ["Canberra", "Hobart", "Melbourne"] |
| 273 |
) |
| 274 |
|
| 275 |
# With a complex geometry expression |
| 276 |
self.assertFalse( |
| 277 |
SouthTexasCity.objects.filter( |
| 278 |
point__distance_gt=(Union("point", "point"), 0) |
| 279 |
) |
| 280 |
) |
| 281 |
self.assertEqual( |
| 282 |
SouthTexasCity.objects.filter( |
| 283 |
point__distance_lte=(Union("point", "point"), 0) |
| 284 |
).count(), |
| 285 |
SouthTexasCity.objects.count(), |
| 286 |
) |
| 287 |
|
| 288 |
@skipUnlessDBFeature("supports_distances_lookups") |
| 289 |
def test_distance_annotation_group_by(self): |
| 290 |
stx_pnt = self.stx_pnt.transform( |
| 291 |
SouthTexasCity._meta.get_field("point").srid, |
| 292 |
clone=True, |
| 293 |
) |
| 294 |
qs = ( |
| 295 |
SouthTexasCity.objects.annotate( |
| 296 |
relative_distance=Case( |
| 297 |
When(point__distance_lte=(stx_pnt, D(km=20)), then=Value(20)), |
| 298 |
default=Value(100), |
| 299 |
output_field=IntegerField(), |
| 300 |
), |
| 301 |
) |
| 302 |
.values("relative_distance") |
| 303 |
.annotate(count=Count("pk")) |
| 304 |
) |
| 305 |
self.assertCountEqual( |
| 306 |
qs, |
| 307 |
[ |
| 308 |
{"relative_distance": 20, "count": 5}, |
| 309 |
{"relative_distance": 100, "count": 4}, |
| 310 |
], |
| 311 |
) |
| 312 |
|
| 313 |
def test_mysql_geodetic_distance_error(self): |
| 314 |
if not connection.ops.mysql: |
| 315 |
self.skipTest("This is a MySQL-specific test.") |
| 316 |
msg = ( |
| 317 |
"Only numeric values of degree units are allowed on geodetic distance " |
| 318 |
"queries." |
| 319 |
) |
| 320 |
with self.assertRaisesMessage(ValueError, msg): |
| 321 |
AustraliaCity.objects.filter( |
| 322 |
point__distance_lte=(Point(0, 0), D(m=100)) |
| 323 |
).exists() |
| 324 |
|
| 325 |
@skipUnlessDBFeature("supports_dwithin_lookup") |
| 326 |
def test_dwithin_subquery(self): |
| 327 |
"""dwithin lookup in a subquery using OuterRef as a parameter.""" |
| 328 |
qs = CensusZipcode.objects.annotate( |
| 329 |
annotated_value=Exists( |
| 330 |
SouthTexasCity.objects.filter( |
| 331 |
point__dwithin=(OuterRef("poly"), D(m=10)), |
| 332 |
) |
| 333 |
) |
| 334 |
).filter(annotated_value=True) |
| 335 |
self.assertEqual(self.get_names(qs), ["77002", "77025", "77401"]) |
| 336 |
|
| 337 |
@skipUnlessDBFeature("supports_dwithin_lookup", "supports_dwithin_distance_expr") |
| 338 |
def test_dwithin_with_expression_rhs(self): |
| 339 |
# LineString of Wollongong and Adelaide coords. |
| 340 |
ls = LineString(((150.902, -34.4245), (138.6, -34.9258)), srid=4326) |
| 341 |
qs = AustraliaCity.objects.filter( |
| 342 |
point__dwithin=(ls, F("allowed_distance")), |
| 343 |
).order_by("name") |
| 344 |
self.assertEqual( |
| 345 |
self.get_names(qs), |
| 346 |
["Adelaide", "Mittagong", "Shellharbour", "Thirroul", "Wollongong"], |
| 347 |
) |
| 348 |
|
| 349 |
@skipIfDBFeature("supports_dwithin_distance_expr") |
| 350 |
def test_dwithin_with_expression_rhs_not_supported(self): |
| 351 |
ls = LineString(((150.902, -34.4245), (138.6, -34.9258)), srid=4326) |
| 352 |
msg = ( |
| 353 |
"This backend does not support expressions for specifying " |
| 354 |
"distance in the dwithin lookup." |
| 355 |
) |
| 356 |
with self.assertRaisesMessage(NotSupportedError, msg): |
| 357 |
list( |
| 358 |
AustraliaCity.objects.filter( |
| 359 |
point__dwithin=(ls, F("allowed_distance")), |
| 360 |
) |
| 361 |
) |
| 362 |
|
| 363 |
|
| 364 |
""" |
| 365 |
============================= |
| 366 |
Distance functions on PostGIS |
| 367 |
============================= |
| 368 |
|
| 369 |
| Projected Geometry | Lon/lat Geometry | Geography (4326) |
| 370 |
|
| 371 |
ST_Distance(geom1, geom2) | OK (meters) | :-( (degrees) | OK (meters) |
| 372 |
|
| 373 |
ST_Distance(geom1, geom2, use_spheroid=False) | N/A | N/A | OK (meters), less accurate, quick |
| 374 |
|
| 375 |
Distance_Sphere(geom1, geom2) | N/A | OK (meters) | N/A |
| 376 |
|
| 377 |
Distance_Spheroid(geom1, geom2, spheroid) | N/A | OK (meters) | N/A |
| 378 |
|
| 379 |
ST_Perimeter(geom1) | OK | :-( (degrees) | OK |
| 380 |
|
| 381 |
|
| 382 |
================================ |
| 383 |
Distance functions on SpatiaLite |
| 384 |
================================ |
| 385 |
|
| 386 |
| Projected Geometry | Lon/lat Geometry |
| 387 |
|
| 388 |
ST_Distance(geom1, geom2) | OK (meters) | N/A |
| 389 |
|
| 390 |
ST_Distance(geom1, geom2, use_ellipsoid=True) | N/A | OK (meters) |
| 391 |
|
| 392 |
ST_Distance(geom1, geom2, use_ellipsoid=False) | N/A | OK (meters), less accurate, quick |
| 393 |
|
| 394 |
Perimeter(geom1) | OK | :-( (degrees) |
| 395 |
|
| 396 |
""" # NOQA |
| 397 |
|
| 398 |
|
| 399 |
class DistanceFunctionsTests(FuncTestMixin, TestCase): |
| 400 |
fixtures = ["initial"] |
| 401 |
|
| 402 |
@skipUnlessDBFeature("has_Area_function") |
| 403 |
def test_area(self): |
| 404 |
# Reference queries: |
| 405 |
# SELECT ST_Area(poly) FROM distapp_southtexaszipcode; |
| 406 |
area_sq_m = [ |
| 407 |
5437908.90234375, |
| 408 |
10183031.4389648, |
| 409 |
11254471.0073242, |
| 410 |
9881708.91772461, |
| 411 |
] |
| 412 |
# Tolerance has to be lower for Oracle |
| 413 |
tol = 2 |
| 414 |
for i, z in enumerate( |
| 415 |
SouthTexasZipcode.objects.annotate(area=Area("poly")).order_by("name") |
| 416 |
): |
| 417 |
self.assertAlmostEqual(area_sq_m[i], z.area.sq_m, tol) |
| 418 |
|
| 419 |
@skipUnlessDBFeature("has_Distance_function") |
| 420 |
def test_distance_simple(self): |
| 421 |
""" |
| 422 |
Test a simple distance query, with projected coordinates and without |
| 423 |
transformation. |
| 424 |
""" |
| 425 |
lagrange = GEOSGeometry("POINT(805066.295722839 4231496.29461335)", 32140) |
| 426 |
houston = ( |
| 427 |
SouthTexasCity.objects.annotate(dist=Distance("point", lagrange)) |
| 428 |
.order_by("id") |
| 429 |
.first() |
| 430 |
) |
| 431 |
tol = 2 if connection.ops.oracle else 5 |
| 432 |
self.assertAlmostEqual(houston.dist.m, 147075.069813, tol) |
| 433 |
|
| 434 |
@skipUnlessDBFeature("has_Distance_function", "has_Transform_function") |
| 435 |
def test_distance_projected(self): |
| 436 |
""" |
| 437 |
Test the `Distance` function on projected coordinate systems. |
| 438 |
""" |
| 439 |
# The point for La Grange, TX |
| 440 |
lagrange = GEOSGeometry("POINT(-96.876369 29.905320)", 4326) |
| 441 |
# Reference distances in feet and in meters. Got these values from |
| 442 |
# using the provided raw SQL statements. |
| 443 |
# SELECT ST_Distance( |
| 444 |
# point, |
| 445 |
# ST_Transform(ST_GeomFromText('POINT(-96.876369 29.905320)', 4326), 32140) |
| 446 |
# ) |
| 447 |
# FROM distapp_southtexascity; |
| 448 |
m_distances = [ |
| 449 |
147075.069813, |
| 450 |
139630.198056, |
| 451 |
140888.552826, |
| 452 |
138809.684197, |
| 453 |
158309.246259, |
| 454 |
212183.594374, |
| 455 |
70870.188967, |
| 456 |
165337.758878, |
| 457 |
139196.085105, |
| 458 |
] |
| 459 |
# SELECT ST_Distance( |
| 460 |
# point, |
| 461 |
# ST_Transform(ST_GeomFromText('POINT(-96.876369 29.905320)', 4326), 2278) |
| 462 |
# ) |
| 463 |
# FROM distapp_southtexascityft; |
| 464 |
ft_distances = [ |
| 465 |
482528.79154625, |
| 466 |
458103.408123001, |
| 467 |
462231.860397575, |
| 468 |
455411.438904354, |
| 469 |
519386.252102563, |
| 470 |
696139.009211594, |
| 471 |
232513.278304279, |
| 472 |
542445.630586414, |
| 473 |
456679.155883207, |
| 474 |
] |
| 475 |
|
| 476 |
# Testing using different variations of parameters and using models |
| 477 |
# with different projected coordinate systems. |
| 478 |
dist1 = SouthTexasCity.objects.annotate( |
| 479 |
distance=Distance("point", lagrange) |
| 480 |
).order_by("id") |
| 481 |
dist2 = SouthTexasCityFt.objects.annotate( |
| 482 |
distance=Distance("point", lagrange) |
| 483 |
).order_by("id") |
| 484 |
dist_qs = [dist1, dist2] |
| 485 |
|
| 486 |
# Ensuring expected distances are returned for each distance queryset. |
| 487 |
for qs in dist_qs: |
| 488 |
for i, c in enumerate(qs): |
| 489 |
with self.subTest(c=c): |
| 490 |
self.assertAlmostEqual(m_distances[i], c.distance.m, -1) |
| 491 |
self.assertAlmostEqual(ft_distances[i], c.distance.survey_ft, -1) |
| 492 |
|
| 493 |
@skipUnlessDBFeature("has_Distance_function", "supports_distance_geodetic") |
| 494 |
def test_distance_geodetic(self): |
| 495 |
""" |
| 496 |
Test the `Distance` function on geodetic coordinate systems. |
| 497 |
""" |
| 498 |
# Testing geodetic distance calculation with a non-point geometry |
| 499 |
# (a LineString of Wollongong and Shellharbour coords). |
| 500 |
ls = LineString(((150.902, -34.4245), (150.87, -34.5789)), srid=4326) |
| 501 |
|
| 502 |
# Reference query: |
| 503 |
# SELECT ST_distance_sphere( |
| 504 |
# point, |
| 505 |
# ST_GeomFromText('LINESTRING(150.9020 -34.4245,150.8700 -34.5789)', 4326) |
| 506 |
# ) |
| 507 |
# FROM distapp_australiacity ORDER BY name; |
| 508 |
distances = [ |
| 509 |
1120954.92533513, |
| 510 |
140575.720018241, |
| 511 |
640396.662906304, |
| 512 |
60580.9693849269, |
| 513 |
972807.955955075, |
| 514 |
568451.8357838, |
| 515 |
40435.4335201384, |
| 516 |
0, |
| 517 |
68272.3896586844, |
| 518 |
12375.0643697706, |
| 519 |
0, |
| 520 |
] |
| 521 |
qs = AustraliaCity.objects.annotate(distance=Distance("point", ls)).order_by( |
| 522 |
"name" |
| 523 |
) |
| 524 |
for city, distance in zip(qs, distances): |
| 525 |
with self.subTest(city=city, distance=distance): |
| 526 |
# Testing equivalence to within a meter (kilometer on SpatiaLite). |
| 527 |
tol = -3 if connection.ops.spatialite else 0 |
| 528 |
self.assertAlmostEqual(distance, city.distance.m, tol) |
| 529 |
|
| 530 |
@skipUnlessDBFeature("has_Distance_function", "supports_distance_geodetic") |
| 531 |
def test_distance_geodetic_spheroid(self): |
| 532 |
tol = 2 if connection.ops.oracle else 4 |
| 533 |
|
| 534 |
# Got the reference distances using the raw SQL statements: |
| 535 |
# SELECT ST_distance_spheroid( |
| 536 |
# point, |
| 537 |
# ST_GeomFromText('POINT(151.231341 -33.952685)', 4326), |
| 538 |
# 'SPHEROID["WGS 84",6378137.0,298.257223563]' |
| 539 |
# ) |
| 540 |
# FROM distapp_australiacity WHERE (NOT (id = 11)); |
| 541 |
# SELECT ST_distance_sphere( |
| 542 |
# point, |
| 543 |
# ST_GeomFromText('POINT(151.231341 -33.952685)', 4326) |
| 544 |
# ) |
| 545 |
# FROM distapp_australiacity WHERE (NOT (id = 11)); st_distance_sphere |
| 546 |
spheroid_distances = [ |
| 547 |
60504.0628957201, |
| 548 |
77023.9489850262, |
| 549 |
49154.8867574404, |
| 550 |
90847.4358768573, |
| 551 |
217402.811919332, |
| 552 |
709599.234564757, |
| 553 |
640011.483550888, |
| 554 |
7772.00667991925, |
| 555 |
1047861.78619339, |
| 556 |
1165126.55236034, |
| 557 |
] |
| 558 |
sphere_distances = [ |
| 559 |
60580.9693849267, |
| 560 |
77144.0435286473, |
| 561 |
49199.4415344719, |
| 562 |
90804.7533823494, |
| 563 |
217713.384600405, |
| 564 |
709134.127242793, |
| 565 |
639828.157159169, |
| 566 |
7786.82949717788, |
| 567 |
1049204.06569028, |
| 568 |
1162623.7238134, |
| 569 |
] |
| 570 |
# Testing with spheroid distances first. |
| 571 |
hillsdale = AustraliaCity.objects.get(name="Hillsdale") |
| 572 |
qs = ( |
| 573 |
AustraliaCity.objects.exclude(id=hillsdale.id) |
| 574 |
.annotate(distance=Distance("point", hillsdale.point, spheroid=True)) |
| 575 |
.order_by("id") |
| 576 |
) |
| 577 |
for i, c in enumerate(qs): |
| 578 |
with self.subTest(c=c): |
| 579 |
self.assertAlmostEqual(spheroid_distances[i], c.distance.m, tol) |
| 580 |
if connection.ops.postgis or connection.ops.spatialite: |
| 581 |
# PostGIS uses sphere-only distances by default, testing these as well. |
| 582 |
qs = ( |
| 583 |
AustraliaCity.objects.exclude(id=hillsdale.id) |
| 584 |
.annotate(distance=Distance("point", hillsdale.point)) |
| 585 |
.order_by("id") |
| 586 |
) |
| 587 |
for i, c in enumerate(qs): |
| 588 |
with self.subTest(c=c): |
| 589 |
self.assertAlmostEqual(sphere_distances[i], c.distance.m, tol) |
| 590 |
|
| 591 |
@skipIfDBFeature("supports_distance_geodetic") |
| 592 |
@skipUnlessDBFeature("has_Distance_function") |
| 593 |
def test_distance_function_raw_result(self): |
| 594 |
distance = ( |
| 595 |
Interstate.objects.annotate( |
| 596 |
d=Distance(Point(0, 0, srid=4326), Point(0, 1, srid=4326)), |
| 597 |
) |
| 598 |
.first() |
| 599 |
.d |
| 600 |
) |
| 601 |
self.assertEqual(distance, 1) |
| 602 |
|
| 603 |
@skipUnlessDBFeature("has_Distance_function") |
| 604 |
def test_distance_function_d_lookup(self): |
| 605 |
qs = Interstate.objects.annotate( |
| 606 |
d=Distance(Point(0, 0, srid=3857), Point(0, 1, srid=3857)), |
| 607 |
).filter(d=D(m=1)) |
| 608 |
self.assertTrue(qs.exists()) |
| 609 |
|
| 610 |
@skipUnlessDBFeature("supports_tolerance_parameter") |
| 611 |
def test_distance_function_tolerance_escaping(self): |
| 612 |
qs = ( |
| 613 |
Interstate.objects.annotate( |
| 614 |
d=Distance( |
| 615 |
Point(500, 500, srid=3857), |
| 616 |
Point(0, 0, srid=3857), |
| 617 |
tolerance="0.05) = 1 OR 1=1 OR (1+1", |
| 618 |
), |
| 619 |
) |
| 620 |
.filter(d=D(m=1)) |
| 621 |
.values("pk") |
| 622 |
) |
| 623 |
msg = "The tolerance parameter has the wrong type" |
| 624 |
with self.assertRaisesMessage(TypeError, msg): |
| 625 |
qs.exists() |
| 626 |
|
| 627 |
@skipUnlessDBFeature("supports_tolerance_parameter") |
| 628 |
def test_distance_function_tolerance(self): |
| 629 |
# Tolerance is greater than distance. |
| 630 |
qs = ( |
| 631 |
Interstate.objects.annotate( |
| 632 |
d=Distance( |
| 633 |
Point(0, 0, srid=3857), |
| 634 |
Point(1, 1, srid=3857), |
| 635 |
tolerance=1.5, |
| 636 |
), |
| 637 |
) |
| 638 |
.filter(d=0) |
| 639 |
.values("pk") |
| 640 |
) |
| 641 |
self.assertIs(qs.exists(), True) |
| 642 |
|
| 643 |
@skipIfDBFeature("supports_distance_geodetic") |
| 644 |
@skipUnlessDBFeature("has_Distance_function") |
| 645 |
def test_distance_function_raw_result_d_lookup(self): |
| 646 |
qs = Interstate.objects.annotate( |
| 647 |
d=Distance(Point(0, 0, srid=4326), Point(0, 1, srid=4326)), |
| 648 |
).filter(d=D(m=1)) |
| 649 |
msg = "Distance measure is supplied, but units are unknown for result." |
| 650 |
with self.assertRaisesMessage(ValueError, msg): |
| 651 |
list(qs) |
| 652 |
|
| 653 |
@skipUnlessDBFeature("has_Distance_function", "has_Transform_function") |
| 654 |
def test_distance_transform(self): |
| 655 |
""" |
| 656 |
Test the `Distance` function used with `Transform` on a geographic field. |
| 657 |
""" |
| 658 |
# We'll be using a Polygon (created by buffering the centroid |
| 659 |
# of 77005 to 100m) -- which aren't allowed in geographic distance |
| 660 |
# queries normally, however our field has been transformed to |
| 661 |
# a non-geographic system. |
| 662 |
z = SouthTexasZipcode.objects.get(name="77005") |
| 663 |
|
| 664 |
# Reference query: |
| 665 |
# SELECT ST_Distance(ST_Transform("distapp_censuszipcode"."poly", 32140), |
| 666 |
# ST_GeomFromText('<buffer_wkt>', 32140)) |
| 667 |
# FROM "distapp_censuszipcode"; |
| 668 |
dists_m = [3553.30384972258, 1243.18391525602, 2186.15439472242] |
| 669 |
|
| 670 |
# Having our buffer in the SRID of the transformation and of the field |
| 671 |
# -- should get the same results. The first buffer has no need for |
| 672 |
# transformation SQL because it is the same SRID as what was given |
| 673 |
# to `transform()`. The second buffer will need to be transformed, |
| 674 |
# however. |
| 675 |
buf1 = z.poly.centroid.buffer(100) |
| 676 |
buf2 = buf1.transform(4269, clone=True) |
| 677 |
ref_zips = ["77002", "77025", "77401"] |
| 678 |
|
| 679 |
for buf in [buf1, buf2]: |
| 680 |
qs = ( |
| 681 |
CensusZipcode.objects.exclude(name="77005") |
| 682 |
.annotate(distance=Distance(Transform("poly", 32140), buf)) |
| 683 |
.order_by("name") |
| 684 |
) |
| 685 |
self.assertEqual(ref_zips, sorted(c.name for c in qs)) |
| 686 |
for i, z in enumerate(qs): |
| 687 |
self.assertAlmostEqual(z.distance.m, dists_m[i], 5) |
| 688 |
|
| 689 |
@skipUnlessDBFeature("has_Distance_function") |
| 690 |
def test_distance_order_by(self): |
| 691 |
qs = ( |
| 692 |
SouthTexasCity.objects.annotate( |
| 693 |
distance=Distance("point", Point(3, 3, srid=32140)) |
| 694 |
) |
| 695 |
.order_by("distance") |
| 696 |
.values_list("name", flat=True) |
| 697 |
.filter(name__in=("San Antonio", "Pearland")) |
| 698 |
) |
| 699 |
self.assertSequenceEqual(qs, ["San Antonio", "Pearland"]) |
| 700 |
|
| 701 |
@skipUnlessDBFeature("has_Length_function") |
| 702 |
def test_length(self): |
| 703 |
""" |
| 704 |
Test the `Length` function. |
| 705 |
""" |
| 706 |
# Reference query (should use `length_spheroid`). |
| 707 |
# SELECT ST_length_spheroid( |
| 708 |
# ST_GeomFromText('<wkt>', 4326) |
| 709 |
# 'SPHEROID["WGS 84",6378137,298.257223563, AUTHORITY["EPSG","7030"]]' |
| 710 |
# ); |
| 711 |
len_m1 = 473504.769553813 |
| 712 |
len_m2 = 4617.668 |
| 713 |
|
| 714 |
if connection.features.supports_length_geodetic: |
| 715 |
qs = Interstate.objects.annotate(length=Length("path")) |
| 716 |
tol = 2 if connection.ops.oracle else 3 |
| 717 |
self.assertAlmostEqual(len_m1, qs[0].length.m, tol) |
| 718 |
# TODO: test with spheroid argument (True and False) |
| 719 |
else: |
| 720 |
# Does not support geodetic coordinate systems. |
| 721 |
with self.assertRaises(NotSupportedError): |
| 722 |
list(Interstate.objects.annotate(length=Length("path"))) |
| 723 |
|
| 724 |
# Now doing length on a projected coordinate system. |
| 725 |
i10 = SouthTexasInterstate.objects.annotate(length=Length("path")).get( |
| 726 |
name="I-10" |
| 727 |
) |
| 728 |
self.assertAlmostEqual(len_m2, i10.length.m, 2) |
| 729 |
self.assertTrue( |
| 730 |
SouthTexasInterstate.objects.annotate(length=Length("path")) |
| 731 |
.filter(length__gt=4000) |
| 732 |
.exists() |
| 733 |
) |
| 734 |
# Length with an explicit geometry value. |
| 735 |
qs = Interstate.objects.annotate(length=Length(i10.path)) |
| 736 |
self.assertAlmostEqual(qs.first().length.m, len_m2, 2) |
| 737 |
|
| 738 |
@skipUnlessDBFeature("has_Perimeter_function") |
| 739 |
def test_perimeter(self): |
| 740 |
""" |
| 741 |
Test the `Perimeter` function. |
| 742 |
""" |
| 743 |
# Reference query: |
| 744 |
# SELECT ST_Perimeter(distapp_southtexaszipcode.poly) |
| 745 |
# FROM distapp_southtexaszipcode; |
| 746 |
perim_m = [ |
| 747 |
18404.3550889361, |
| 748 |
15627.2108551001, |
| 749 |
20632.5588368978, |
| 750 |
17094.5996143697, |
| 751 |
] |
| 752 |
tol = 2 if connection.ops.oracle else 7 |
| 753 |
qs = SouthTexasZipcode.objects.annotate(perimeter=Perimeter("poly")).order_by( |
| 754 |
"name" |
| 755 |
) |
| 756 |
for i, z in enumerate(qs): |
| 757 |
self.assertAlmostEqual(perim_m[i], z.perimeter.m, tol) |
| 758 |
|
| 759 |
# Running on points; should return 0. |
| 760 |
qs = SouthTexasCity.objects.annotate(perim=Perimeter("point")) |
| 761 |
for city in qs: |
| 762 |
self.assertEqual(0, city.perim.m) |
| 763 |
|
| 764 |
@skipUnlessDBFeature("has_Perimeter_function") |
| 765 |
def test_perimeter_geodetic(self): |
| 766 |
# Currently only Oracle supports calculating the perimeter on geodetic |
| 767 |
# geometries (without being transformed). |
| 768 |
qs1 = CensusZipcode.objects.annotate(perim=Perimeter("poly")) |
| 769 |
if connection.features.supports_perimeter_geodetic: |
| 770 |
self.assertAlmostEqual(qs1[0].perim.m, 18406.3818954314, 3) |
| 771 |
else: |
| 772 |
with self.assertRaises(NotSupportedError): |
| 773 |
list(qs1) |
| 774 |
# But should work fine when transformed to projected coordinates |
| 775 |
qs2 = CensusZipcode.objects.annotate( |
| 776 |
perim=Perimeter(Transform("poly", 32140)) |
| 777 |
).filter(name="77002") |
| 778 |
self.assertAlmostEqual(qs2[0].perim.m, 18404.355, 3) |
| 779 |
|
| 780 |
@skipUnlessDBFeature( |
| 781 |
"supports_null_geometries", "has_Area_function", "has_Distance_function" |
| 782 |
) |
| 783 |
def test_measurement_null_fields(self): |
| 784 |
""" |
| 785 |
Test the measurement functions on fields with NULL values. |
| 786 |
""" |
| 787 |
# Creating SouthTexasZipcode w/NULL value. |
| 788 |
SouthTexasZipcode.objects.create(name="78212") |
| 789 |
# Performing distance/area queries against the NULL PolygonField, |
| 790 |
# and ensuring the result of the operations is None. |
| 791 |
htown = SouthTexasCity.objects.get(name="Downtown Houston") |
| 792 |
z = SouthTexasZipcode.objects.annotate( |
| 793 |
distance=Distance("poly", htown.point), area=Area("poly") |
| 794 |
).get(name="78212") |
| 795 |
self.assertIsNone(z.distance) |
| 796 |
self.assertIsNone(z.area) |