def test_point_at_end_of_path_not_moving_after_mutate(self):
PathFactory.create(geom=LineString((400, 400), (410, 400), srid=settings.SRID))
self.assertEqual(1, len(Path.objects.all()))
father = Topology.deserialize({"lat": -1, "lng": -1})
poi = Point(500, 600, srid=settings.SRID)
poi.transform(settings.API_SRID)
son = Topology.deserialize({"lat": poi.y, "lng": poi.x})
father.mutate(son)
self.assertTrue(almostequal(father.geom.x, 500))
self.assertTrue(almostequal(father.geom.y, 600))
def test_point_geom_not_moving(self):
"""
Modify path, point not moving
+ +
| |
\ X / X
/ \
| |
+ +
"""
p1 = PathFactory.create(geom=LineString((0, 0, 0),
(0, 5, 0),
(5, 10, 0),
(0, 15, 0),
(0, 20, 0)))
poi = Point(10, 10, srid=settings.SRID)
poi.transform(settings.API_SRID)
poitopo = Topology.deserialize({'lat': poi.y, 'lng': poi.x})
self.assertEqual(0.5, poitopo.aggregations.all()[0].start_position)
self.assertTrue(almostequal(-5, poitopo.offset))
# It should have kept its position !
self.assertTrue(almostequal(10, poitopo.geom.x))
self.assertTrue(almostequal(10, poitopo.geom.y))
# Change path, it should still be in the same position
p1.geom = LineString((0, 0, 0),
(0, 5, 0),
(-5, 10, 0),
(0, 15, 0),
(0, 20, 0))
p1.save()
poitopo.reload()
self.assertTrue(almostequal(10, poitopo.geom.x))
self.assertTrue(almostequal(10, poitopo.geom.y))
def test_return_path_serialized(self):
"""
Same as test_return_path() but from deserialization.
"""
p1 = PathFactory.create(geom=LineString((0, 0), (10, 0)))
p2 = PathFactory.create(geom=LineString((5, 0), (5, 10), (10, 10)))
p3 = Path.objects.filter(name=p1.name).exclude(pk=p1.pk)[0] # Was splitted :)
topo = Topology.deserialize(
"""
[{"offset":0,
"positions":{"0":[0.5,1],
"1":[0.0, 0.8]},
"paths":[%(p1)s,%(p2)s]
},
{"offset":0,
"positions":{"0":[0.8,0.0],
"1":[0.0, 0.5]},
"paths":[%(p2)s,%(p3)s]
}
]
"""
% {"p1": p1.pk, "p2": p2.pk, "p3": p3.pk}
)
topo.save()
self.assertEqual(topo.geom, LineString((2.5, 0), (5, 0), (5, 10), (7, 10), (5, 10), (5, 0), (7.5, 0)))
def test_spoon_loop_2(self):
"""
=====>====
|| ||
+-------===<===>===+=====<===
"""
p1 = PathFactory.create(geom=LineString((0, 0, 0), (10, 0, 0)))
p2 = PathFactory.create(geom=LineString((10, 0, 0), (10, 5, 0),
(20, 5, 0), (20, 0, 0),
(10, 0, 0)))
topo = TopologyFactory.create(no_path=True)
topo.add_path(p1, start=0.3, end=1)
topo.add_path(p2, start=0, end=0.4)
topo.add_path(p2, start=0.4, end=0.4)
topo.add_path(p2, start=0.4, end=0.8)
topo.add_path(p2, start=0.8, end=0.8)
topo.add_path(p2, start=0.8, end=1.0)
topo.add_path(p1, start=1, end=0.3)
topo.save()
self.assertEqual(topo.geom, LineString((3, 0, 0), (10, 0, 0), (10, 5, 0),
(17, 5, 0), (20, 5, 0), # extra point due middle aggregation
(20, 0, 0), (16, 0, 0), (10, 0, 0), (3, 0, 0)))
# De/Serializing should work too
serialized = """
[{"kind": "TOPOLOGY","positions":{"0":[0.3,1],"1":[0, 0.4]},"paths":[%(pk1)s,%(pk2)s],"offset": 0.0},
{"kind": "TOPOLOGY","positions":{"0":[0.4, 0.8]},"paths":[%(pk2)s],"offset": 0.0},
{"kind": "TOPOLOGY","positions":{"0":[0.8,1],"1":[1,0.3]},"paths":[%(pk2)s,%(pk1)s],"offset": 0.0}]""" % {'pk1': p1.pk, 'pk2': p2.pk}
self.assertEqual(json.loads(serialized), json.loads(topo.serialize()))
topod = Topology.deserialize(serialized)
self.assertEqual(topo.geom, topod.geom)
self.assertEqual(len(topod.aggregations.all()), 7)
def test_point_geom_3d(self):
"""
+
/ \
/ X \
+ +
"""
p1 = PathFactory.create(geom=LineString((0, 0, 1000), (4, 4, 2000)))
p2 = PathFactory.create(geom=LineString((4, 4, 2000), (8, 0, 0)))
poi = Point(3, 1, srid=settings.SRID)
position, distance = Path.interpolate(p1, poi)
self.assertTrue(almostequal(0.5, position))
self.assertTrue(almostequal(-1.414, distance))
# Verify that deserializing this, we obtain the same original coordinates
# (use lat/lng as in forms)
poi.transform(settings.API_SRID)
poitopo = Topology.deserialize({'lat': poi.y, 'lng': poi.x})
# Computed topology properties match original interpolation
self.assertTrue(almostequal(0.5, poitopo.aggregations.all()[0].start_position))
self.assertTrue(almostequal(-1.414, poitopo.offset))
# Resulting geometry
self.assertTrue(almostequal(3, poitopo.geom.x))
self.assertTrue(almostequal(1, poitopo.geom.y))
self.assertTrue(almostequal(0, poitopo.geom.z))
def test_spoon_loop(self):
"""
=====<====
|| ||
+-------===<===>===+=====>===
"""
p1 = PathFactory.create(geom=LineString((0, 0, 0), (10, 0, 0)))
p2 = PathFactory.create(geom=LineString((10, 0, 0), (10, 5, 0),
(20, 5, 0), (20, 0, 0),
(10, 0, 0)))
topo = TopologyFactory.create(no_path=True)
topo.add_path(p1, start=0.3, end=1)
topo.add_path(p2, start=1, end=0.4)
topo.add_path(p2, start=0.4, end=0.4)
topo.add_path(p2, start=0.4, end=0.2)
topo.add_path(p2, start=0.2, end=0.2)
topo.add_path(p2, start=0.2, end=0)
topo.add_path(p1, start=1, end=0.3)
topo.save()
self.assertEqual(topo.geom, LineString((3, 0, 0), (10, 0, 0), (20, 0, 0), (20, 5, 0),
(17, 5, 0), (11, 5, 0), # extra point due middle aggregation
(10, 5, 0), (10, 0, 0), (3, 0, 0)))
# Deserializing should work too
topod = Topology.deserialize("""
[{"positions":{"0":[0.3,1],"1":[1, 0.4]},"paths":[%(pk1)s,%(pk2)s]},
{"positions":{"0":[0.4, 0.2]},"paths":[%(pk2)s]},
{"positions":{"0":[0.2,0],"1":[1,0.3]},"paths":[%(pk2)s,%(pk1)s]}]""" % {'pk1': p1.pk, 'pk2': p2.pk})
self.assertEqual(topo.geom, topod.geom)
self.assertEqual(len(topod.aggregations.all()), 7)
def test_deserialize_line(self):
path = PathFactory.create()
topology = Topology.deserialize('[{"paths": [%s], "positions": {"0": [0.0, 1.0]}, "offset": 1}]' % (path.pk))
self.assertEqual(topology.offset, 1)
self.assertEqual(topology.kind, Topology.KIND)
self.assertEqual(len(topology.paths.all()), 1)
self.assertEqual(topology.aggregations.all()[0].path, path)
self.assertEqual(topology.aggregations.all()[0].start_position, 0.0)
self.assertEqual(topology.aggregations.all()[0].end_position, 1.0)
def test_deserialize_multiple_lines(self):
# Multiple paths
p1 = PathFactory.create(geom=LineString((0, 0, 0), (2, 2, 2)))
p2 = PathFactory.create(geom=LineString((2, 2, 2), (2, 0, 0)))
p3 = PathFactory.create(geom=LineString((2, 0, 0), (4, 0, 0)))
pks = [p.pk for p in [p1, p2, p3]]
topology = Topology.deserialize('{"paths": %s, "positions": {"0": [0.0, 1.0], "2": [0.0, 1.0]}, "offset": 1}' % (pks))
for i in range(3):
self.assertEqual(topology.aggregations.all()[i].start_position, 0.0)
self.assertEqual(topology.aggregations.all()[i].end_position, 1.0)
topology = Topology.deserialize('{"paths": %s, "positions": {"0": [0.3, 1.0], "2": [0.0, 0.7]}, "offset": 1}' % (pks))
self.assertEqual(topology.aggregations.all()[0].start_position, 0.3)
self.assertEqual(topology.aggregations.all()[0].end_position, 1.0)
self.assertEqual(topology.aggregations.all()[1].start_position, 0.0)
self.assertEqual(topology.aggregations.all()[1].end_position, 1.0)
self.assertEqual(topology.aggregations.all()[2].start_position, 0.0)
self.assertEqual(topology.aggregations.all()[2].end_position, 0.7)
def test_deserialize_line(self):
path = PathFactory.create()
topology = Topology.deserialize(
'[{"paths": [%s], "positions": {"0": [0.0, 1.0]}, "offset": 1}]' %
(path.pk))
self.assertEqual(topology.offset, 1)
self.assertEqual(topology.kind, Topology.KIND)
self.assertEqual(len(topology.paths.all()), 1)
self.assertEqual(topology.aggregations.all()[0].path, path)
self.assertEqual(topology.aggregations.all()[0].start_position, 0.0)
self.assertEqual(topology.aggregations.all()[0].end_position, 1.0)
def create_signage(self, geometry, name, type, condition, structure,
description, year, verbosity, eid, use_structure):
infra_type, created = SignageType.objects.get_or_create(
label=type, structure=structure if use_structure else None)
if created and verbosity:
self.stdout.write("- SignageType '{}' created".format(infra_type))
if condition:
condition_type, created = InfrastructureCondition.objects.get_or_create(
label=condition,
structure=structure if use_structure else None)
if created and verbosity:
self.stdout.write(
"- Condition Type '{}' created".format(condition_type))
else:
condition_type = None
with transaction.atomic():
fields_without_eid = {
'type': infra_type,
'name': name,
'condition': condition_type,
'structure': structure,
'description': description,
'implantation_year': year
}
if eid:
infra, created = Signage.objects.update_or_create(
eid=eid, defaults=fields_without_eid)
if verbosity > 0 and not created:
self.stdout.write("Update : %s with eid %s" % (name, eid))
else:
infra = Signage.objects.create(**fields_without_eid)
if settings.TREKKING_TOPOLOGY_ENABLED:
try:
geometry = geometry.transform(settings.API_SRID, clone=True)
geometry.coord_dim = 2
serialized = '{"lng": %s, "lat": %s}' % (geometry.x,
geometry.y)
topology = Topology.deserialize(serialized)
infra.mutate(topology)
except IndexError:
raise GEOSException('Invalid Geometry type.')
else:
if geometry.geom_type != 'Point':
raise GEOSException('Invalid Geometry type.')
geometry = geometry.transform(settings.SRID, clone=True)
infra.geom = Point(geometry.x, geometry.y)
infra.save()
self.counter += 1
return infra
def test_point_geom_moving(self):
p1 = PathFactory.create(geom=LineString((0, 0), (0, 5)))
poi = Point(0, 2.5, srid=settings.SRID)
poi.transform(settings.API_SRID)
poitopo = Topology.deserialize({"lat": poi.y, "lng": poi.x})
self.assertTrue(almostequal(0.5, poitopo.aggregations.all()[0].start_position))
self.assertTrue(almostequal(0, poitopo.offset))
self.assertTrue(almostequal(0, poitopo.geom.x))
self.assertTrue(almostequal(2.5, poitopo.geom.y))
p1.geom = LineString((10, 0), (10, 5))
p1.save()
poitopo.reload()
self.assertTrue(almostequal(10, poitopo.geom.x))
self.assertTrue(almostequal(2.5, poitopo.geom.y))
def test_deserialize_serialize(self):
path = PathFactory.create(geom=LineString((1, 1), (2, 2), (2, 0)))
before = TopologyFactory.create(offset=1, paths=[(path, 0.5, 0.5)])
# Deserialize its serialized version !
after = Topology.deserialize(before.serialize())
self.assertEqual(len(before.paths.all()), len(after.paths.all()))
start_before = before.aggregations.all()[0].start_position
end_before = before.aggregations.all()[0].end_position
start_after = after.aggregations.all()[0].start_position
end_after = after.aggregations.all()[0].end_position
self.assertAlmostEqual(start_before, start_after, places=6)
self.assertAlmostEqual(end_before, end_after, places=6)
def test_deserialize_multiple_lines(self):
# Multiple paths
p1 = PathFactory.create(geom=LineString((0, 0), (2, 2)))
p2 = PathFactory.create(geom=LineString((2, 2), (2, 0)))
p3 = PathFactory.create(geom=LineString((2, 0), (4, 0)))
pks = [p.pk for p in [p1, p2, p3]]
topology = Topology.deserialize(
'{"paths": %s, "positions": {"0": [0.0, 1.0], "2": [0.0, 1.0]}, "offset": 1}'
% (pks))
for i in range(3):
self.assertEqual(topology.aggregations.all()[i].start_position,
0.0)
self.assertEqual(topology.aggregations.all()[i].end_position, 1.0)
topology = Topology.deserialize(
'{"paths": %s, "positions": {"0": [0.3, 1.0], "2": [0.0, 0.7]}, "offset": 1}'
% (pks))
self.assertEqual(topology.aggregations.all()[0].start_position, 0.3)
self.assertEqual(topology.aggregations.all()[0].end_position, 1.0)
self.assertEqual(topology.aggregations.all()[1].start_position, 0.0)
self.assertEqual(topology.aggregations.all()[1].end_position, 1.0)
self.assertEqual(topology.aggregations.all()[2].start_position, 0.0)
self.assertEqual(topology.aggregations.all()[2].end_position, 0.7)
def test_deserialize_serialize(self):
path = PathFactory.create(geom=LineString((1, 1), (2, 2), (2, 0)))
before = TopologyFactory.create(offset=1, no_path=True)
before.add_path(path, start=0.5, end=0.5)
# Deserialize its serialized version !
after = Topology.deserialize(before.serialize())
self.assertEqual(len(before.paths.all()), len(after.paths.all()))
start_before = before.aggregations.all()[0].start_position
end_before = before.aggregations.all()[0].end_position
start_after = after.aggregations.all()[0].start_position
end_after = after.aggregations.all()[0].end_position
self.assertTrue(almostequal(start_before, start_after), '%s != %s' % (start_before, start_after))
self.assertTrue(almostequal(end_before, end_after), '%s != %s' % (end_before, end_after))
def test_deserialize_serialize(self):
path = PathFactory.create(geom=LineString((1, 1), (2, 2), (2, 0)))
before = TopologyFactory.create(offset=1, no_path=True)
before.add_path(path, start=0.5, end=0.5)
# Deserialize its serialized version !
after = Topology.deserialize(before.serialize())
self.assertEqual(len(before.paths.all()), len(after.paths.all()))
start_before = before.aggregations.all()[0].start_position
end_before = before.aggregations.all()[0].end_position
start_after = after.aggregations.all()[0].start_position
end_after = after.aggregations.all()[0].end_position
self.assertTrue(almostequal(start_before, start_after), '%s != %s' % (start_before, start_after))
self.assertTrue(almostequal(end_before, end_after), '%s != %s' % (end_before, end_after))
def test_deserialize_point(self):
PathFactory.create()
# Take a point
p = Point(2, 1, 0, srid=settings.SRID)
p.transform(settings.API_SRID)
closest = Path.closest(p)
# Check closest path
self.assertEqual(closest.geom.coords, ((1.0, 1.0, 0.0), (2.0, 2.0, 0.0)))
# The point has same x as first point of path, and y to 0 :
topology = Topology.deserialize('{"lng": %s, "lat": %s}' % (p.x, p.y))
self.assertAlmostEqual(topology.offset, -0.7071, 3)
self.assertEqual(len(topology.paths.all()), 1)
pagg = topology.aggregations.get()
self.assertTrue(almostequal(pagg.start_position, 0.5))
self.assertTrue(almostequal(pagg.end_position, 0.5))
def test_point_geom_moving(self):
p1 = PathFactory.create(geom=LineString((0, 0), (0, 5)))
poi = Point(0, 2.5, srid=settings.SRID)
poi.transform(settings.API_SRID)
poitopo = Topology.deserialize({'lat': poi.y, 'lng': poi.x})
self.assertTrue(
almostequal(0.5,
poitopo.aggregations.all()[0].start_position))
self.assertTrue(almostequal(0, poitopo.offset))
self.assertTrue(almostequal(0, poitopo.geom.x))
self.assertTrue(almostequal(2.5, poitopo.geom.y))
p1.geom = LineString((10, 0), (10, 5))
p1.save()
poitopo.reload()
self.assertTrue(almostequal(10, poitopo.geom.x))
self.assertTrue(almostequal(2.5, poitopo.geom.y))
def test_deserialize_serialize(self):
path = PathFactory.create(geom=LineString((1, 1, 1), (2, 2, 2), (2, 0, 0)))
before = TopologyFactory.create(offset=1, no_path=True)
before.add_path(path, start=0.5, end=0.5)
# Reload from DB
before = Topology.objects.get(pk=before.pk)
# Deserialize its serialized version !
after = Topology.deserialize(before.serialize())
# Reload from DB
after = Topology.objects.get(pk=after.pk)
self.assertEqual(len(before.paths.all()), len(after.paths.all()))
self.assertTrue(almostequal(before.aggregations.all()[0].start_position,
after.aggregations.all()[0].start_position))
self.assertTrue(almostequal(before.aggregations.all()[0].end_position,
after.aggregations.all()[0].end_position))
def test_spoon_loop_2(self):
"""
=====>====
|| ||
+-------===<===>===+=====<===
"""
p1 = PathFactory.create(geom=LineString((0, 0), (10, 0)))
p2 = PathFactory.create(
geom=LineString((10, 0), (10, 5), (20, 5), (20, 0), (10, 0)))
topo = TopologyFactory.create(no_path=True)
topo.add_path(p1, start=0.3, end=1, order=1)
topo.add_path(p2, start=0, end=0.4, order=2)
topo.add_path(p2, start=0.4, end=0.4, order=3)
topo.add_path(p2, start=0.4, end=0.8, order=4)
topo.add_path(p2, start=0.8, end=0.8, order=5)
topo.add_path(p2, start=0.8, end=1.0, order=6)
topo.add_path(p1, start=1, end=0.3, order=7)
topo.save()
self.assertEqual(
topo.geom,
LineString(
(3, 0),
(10, 0),
(10, 5),
(17, 5),
(20, 5), # extra point due middle aggregation
(20, 0),
(16, 0),
(10, 0),
(3, 0),
srid=settings.SRID))
# De/Serializing should work too
serialized = """
[{"kind": "TOPOLOGY","positions":{"0":[0.3,1],"1":[0, 0.4]},"paths":[%(pk1)s,%(pk2)s],"offset": 0.0,"pk": %(topo)s},
{"kind": "TOPOLOGY","positions":{"0":[0.4, 0.8]},"paths":[%(pk2)s],"offset": 0.0,"pk": %(topo)s},
{"kind": "TOPOLOGY","positions":{"0":[0.8,1],"1":[1,0.3]},"paths":[%(pk2)s,%(pk1)s],"offset": 0.0,"pk": %(topo)s}]""" % {
'topo': topo.pk,
'pk1': p1.pk,
'pk2': p2.pk
}
self.assertEqual(json.loads(serialized), json.loads(topo.serialize()))
topod = Topology.deserialize(serialized)
self.assertEqual(topo.geom, topod.geom)
self.assertEqual(len(topod.aggregations.all()), 7)
def test_spoon_loop(self):
"""
=====<====
|| ||
+-------===<===>===+=====>===
"""
p1 = PathFactory.create(geom=LineString((0, 0), (10, 0)))
p2 = PathFactory.create(
geom=LineString((10, 0), (10, 5), (20, 5), (20, 0), (10, 0)))
topo = TopologyFactory.create(no_path=True)
topo.add_path(p1, start=0.3, end=1, order=0)
topo.add_path(p2, start=1, end=0.4, order=1)
topo.add_path(p2, start=0.4, end=0.4, order=2)
topo.add_path(p2, start=0.4, end=0.2, order=3)
topo.add_path(p2, start=0.2, end=0.2, order=4)
topo.add_path(p2, start=0.2, end=0, order=5)
topo.add_path(p1, start=1, end=0.3, order=6)
topo.save()
self.assertEqual(
topo.geom,
LineString(
(3, 0),
(10, 0),
(20, 0),
(20, 5),
(17, 5),
(11, 5), # extra point due middle aggregation
(10, 5),
(10, 0),
(3, 0),
srid=settings.SRID))
# Deserializing should work too
topod = Topology.deserialize("""
[{"positions":{"0":[0.3,1],"1":[1, 0.4]},"paths":[%(pk1)s,%(pk2)s]},
{"positions":{"0":[0.4, 0.2]},"paths":[%(pk2)s]},
{"positions":{"0":[0.2,0],"1":[1,0.3]},"paths":[%(pk2)s,%(pk1)s]}]"""
% {
'pk1': p1.pk,
'pk2': p2.pk
})
self.assertEqual(topo.geom, topod.geom)
self.assertEqual(len(topod.aggregations.all()), 7)
def test_spoon_loop(self):
"""
=====<====
|| ||
+-------===<===>===+=====>===
"""
p1 = PathFactory.create(geom=LineString((0, 0), (10, 0)))
p2 = PathFactory.create(
geom=LineString((10, 0), (10, 5), (20, 5), (20, 0), (10, 0)))
topo = TopologyFactory.create(
paths=[(p1, 0.3,
1), (p2, 1, 0.4), (p2, 0.4,
0.4), (p2, 0.4,
0.2), (p2, 0.2,
0.2), (p2, 0.2,
0), (p1, 1, 0.3)])
self.assertEqual(
topo.geom,
LineString(
(3, 0),
(10, 0),
(20, 0),
(20, 5),
(17, 5),
(11, 5), # extra point due middle aggregation
(10, 5),
(10, 0),
(3, 0),
srid=settings.SRID))
# Deserializing should work too
topod = Topology.deserialize("""
[{"positions":{"0":[0.3,1],"1":[1, 0.4]},"paths":[%(pk1)s,%(pk2)s]},
{"positions":{"0":[0.4, 0.2]},"paths":[%(pk2)s]},
{"positions":{"0":[0.2,0],"1":[1,0.3]},"paths":[%(pk2)s,%(pk1)s]}]"""
% {
'pk1': p1.pk,
'pk2': p2.pk
})
topod.kind = 'TOPOLOGY'
topod.save()
self.assertEqual(topo.geom, topod.geom)
self.assertEqual(len(topod.aggregations.all()), 7)
def create_poi(self, geometry, name, poitype, description):
poitype, created = POIType.objects.get_or_create(label=poitype)
poi = POI.objects.create(name=name, type=poitype, description=description)
if settings.TREKKING_TOPOLOGY_ENABLED:
# Use existing topology helpers to transform a Point(x, y)
# to a path aggregation (topology)
geometry = geometry.transform(settings.API_SRID, clone=True)
geometry.coord_dim = 2
serialized = '{"lng": %s, "lat": %s}' % (geometry.x, geometry.y)
topology = Topology.deserialize(serialized)
# Move deserialization aggregations to the POI
poi.mutate(topology)
else:
if geometry.geom_type != 'Point':
raise TypeError
poi.geom = Point(geometry.x, geometry.y, srid=settings.SRID)
poi.save()
self.counter += 1
return poi
def test_point_offset_updated(self):
"""
Shorten path, offset updated.
X X
+-----------+ +------+
"""
p1 = PathFactory.create(geom=LineString((0, 0), (20, 0)))
poi = Point(10, 10, srid=settings.SRID)
poi.transform(settings.API_SRID)
poitopo = Topology.deserialize({'lat': poi.y, 'lng': poi.x})
self.assertTrue(almostequal(0.5, poitopo.aggregations.all()[0].start_position))
self.assertTrue(almostequal(10, poitopo.offset))
p1.geom = LineString((0, 0), (0, 5))
p1.save()
poitopo.reload()
self.assertTrue(almostequal(11.180339887, poitopo.offset))
# Not moved:
self.assertTrue(almostequal(10, poitopo.geom.x))
self.assertTrue(almostequal(10, poitopo.geom.y))
def test_point_offset_updated(self):
"""
Shorten path, offset updated.
X X
+-----------+ +------+
"""
p1 = PathFactory.create(geom=LineString((0, 0), (20, 0)))
poi = Point(10, 10, srid=settings.SRID)
poi.transform(settings.API_SRID)
poitopo = Topology.deserialize({'lat': poi.y, 'lng': poi.x})
self.assertTrue(almostequal(0.5, poitopo.aggregations.all()[0].start_position))
self.assertTrue(almostequal(10, poitopo.offset))
p1.geom = LineString((0, 0), (0, 5))
p1.save()
poitopo.reload()
self.assertTrue(almostequal(11.180339887, poitopo.offset))
# Not moved:
self.assertTrue(almostequal(10, poitopo.geom.x))
self.assertTrue(almostequal(10, poitopo.geom.y))
def test_point_offset_kept(self):
"""
Shorten path, offset kept.
X X
+-----------+ +------+
"""
p1 = PathFactory.create(geom=LineString((0, 0), (20, 0)))
poi = Point(5, 10, srid=settings.SRID)
poi.transform(settings.API_SRID)
poitopo = Topology.deserialize({"lat": poi.y, "lng": poi.x})
self.assertTrue(almostequal(0.25, poitopo.aggregations.all()[0].start_position))
self.assertTrue(almostequal(10, poitopo.offset))
p1.geom = LineString((0, 0), (10, 0))
p1.save()
poitopo.reload()
self.assertTrue(almostequal(10, poitopo.offset))
# Not moved:
self.assertTrue(almostequal(5, poitopo.geom.x))
self.assertTrue(almostequal(10, poitopo.geom.y))
def test_return_path_serialized(self):
"""
Same as test_return_path() but from deserialization.
"""
p1 = PathFactory.create(geom=LineString((0, 0, 0), (10, 0, 0)))
p2 = PathFactory.create(geom=LineString((5, 0, 0), (5, 10, 0), (10, 10, 0)))
p3 = Path.objects.filter(name=p1.name).exclude(pk=p1.pk)[0] # Was splitted :)
topo = Topology.deserialize("""
[{"offset":0,
"positions":{"0":[0.5,1],
"1":[0.0, 0.8]},
"paths":[%(p1)s,%(p2)s]
},
{"offset":0,
"positions":{"0":[0.8,0.0],
"1":[0.0, 0.5]},
"paths":[%(p2)s,%(p3)s]
}
]
""" % {'p1': p1.pk, 'p2': p2.pk, 'p3': p3.pk})
topo.save()
self.assertEqual(topo.geom, LineString((2.5, 0, 0), (5, 0, 0), (5, 10, 0),
(7, 10, 0), (5, 10, 0), (5, 0, 0),
(7.5, 0, 0)))
def test_point_geom_3d(self):
"""
+
/ \
/ X \
+ +
"""
p1 = PathFactory.create(geom=LineString((0, 0), (4, 4)))
PathFactory.create(geom=LineString((4, 4), (8, 0)))
poi = Point(3, 1, srid=settings.SRID)
position, distance = Path.interpolate(p1, poi)
self.assertTrue(almostequal(0.5, position))
self.assertTrue(almostequal(-1.414, distance))
# Verify that deserializing this, we obtain the same original coordinates
# (use lat/lng as in forms)
poi.transform(settings.API_SRID)
poitopo = Topology.deserialize({'lat': poi.y, 'lng': poi.x})
# Computed topology properties match original interpolation
self.assertTrue(almostequal(0.5, poitopo.aggregations.all()[0].start_position))
self.assertTrue(almostequal(-1.414, poitopo.offset))
# Resulting geometry
self.assertTrue(almostequal(3, poitopo.geom.x))
self.assertTrue(almostequal(1, poitopo.geom.y))
def test_deserialize_foreignkey(self):
topology = TopologyFactory.create(offset=1, no_path=True)
deserialized = Topology.deserialize(topology.pk)
self.assertEqual(topology, deserialized)
def test_deserialize_unedited_line_topology(self):
topology = TopologyFactory.create(offset=1)
deserialized = Topology.deserialize([{'pk': topology.pk}, {}])
self.assertEqual(topology, deserialized)
def test_deserialize_foreignkey(self):
topology = TopologyFactory.create(offset=1)
deserialized = Topology.deserialize(topology.pk)
self.assertEqual(topology, deserialized)
def test_deserialize_unedited_point_topology(self):
topology = TopologyFactory.create(offset=1, no_path=True)
deserialized = Topology.deserialize({"pk": topology.pk})
self.assertEqual(topology, deserialized)
def test_topology_deserialize_invalid(self):
with self.assertRaises(ValueError):
Topology.deserialize(
'[{"paths": [4012999999], "positions": {}, "offset": 1}]')
def test_topology_deserialize_inexistant_line(self):
path = PathFactory.create(
geom=LineString((699999, 6600001), (700001, 6600001)))
Topology.deserialize(
'[{"pk": 4012999999, "paths": [%s], "positions": {"0": [0.0, 1.0]}, "offset": 1}]'
% path.pk)
def test_topology_deserialize_inexistant_point(self):
PathFactory.create(
geom=LineString((699999, 6600001), (700001, 6600001)))
Topology.deserialize('{"lat": 46.5, "lng": 3, "pk": 4012999999}')
def test_topology_deserialize_inexistant(self):
with self.assertRaises(Topology.DoesNotExist):
Topology.deserialize('4012999999')
def test_deserialize_unedited_point_topology(self):
topology = TopologyFactory.create(offset=1, no_path=True)
deserialized = Topology.deserialize({'pk': topology.pk})
self.assertEqual(topology, deserialized)
def test_deserialize_unedited_line_topology(self):
topology = TopologyFactory.create(offset=1, no_path=True)
deserialized = Topology.deserialize([{'pk': topology.pk}, {}])
self.assertEqual(topology, deserialized)
