def vector_catalog_save_layer(tenant, layer, vector_layer, features):
connection.close()
connection.set_schema(tenant)
features = VECTOR_LAYERS[vector_layer]['geometries_by_id'](features)
with transaction.atomic():
union = GEOSGeometry('POINT EMPTY')
keys = None
for g, props in features:
if not keys:
keys = props.keys()
union = union.union(g)
g.transform(3857)
s = hashlib.sha1()
s.update(GeometryCollection(g).ewkb)
props['shaid'] = s.hexdigest()
f = Feature(layer=layer,
geometry=GeometryCollection(g),
properties=props)
f.save()
envelope = union.envelope.coords[0]
layer.bounds = envelope[2] + envelope[0]
layer.status = 0
layer.field_names = list(set(layer.field_names).union(set(keys)))
layer.schema['properties'] = {n: "str" for n in layer.field_names}
layer.save()
def geomfield(cls):
from django.contrib.gis.geos import LineString
# Fake field, TODO: still better than overkill code in views, but can do neater.
c = GeometryCollection([LineString((0, 0), (1, 1))],
srid=settings.SRID)
c.name = 'geom'
return c
def get_context(self,
name,
value,
attrs=None,
extra_context={},
renderer=None):
"""Get for display the college polygon"""
context = super(PointWidget, self).get_context(name, value, attrs,
extra_context)
# convert multipoint to geometry collection
geos_obj = fromstr(context['value'])
if isinstance(geos_obj, MultiPoint):
context['value'] = GeometryCollection([p for p in geos_obj]).wkt
elif isinstance(geos_obj, GeometryCollection):
context['value'] = geos_obj.wkt
else:
context['value'] = GeometryCollection(geos_obj).wkt
try:
value = Location.objects.get(name="CollegePlan").polygon
value = geos.GEOSGeometry(value)
context['college_wkt'] = value.wkt
except Location.DoesNotExist:
context['college_wkt'] = ''
return context
def make_geometrycollection_from_featurecollection(self, feature_collection):
geoms = []
#features = json.loads(feature_collection)
gc = GeometryCollection()
for feature in feature_collection['features']:
feature_geom = json.dumps(feature['geometry'])
geos_geom = (GEOSGeometry(feature_geom))
gc.append(geos_geom)
return gc
def save_osm_data(instance_id):
"""
Includes the OSM data in the specified submission json data.
"""
instance = Instance.objects.filter(pk=instance_id).first()
osm_attachments = instance.attachments.filter(extension=Attachment.OSM) \
if instance else None
if instance and osm_attachments:
fields = [
f.get_abbreviated_xpath()
for f in instance.xform.get_survey_elements_of_type('osm')
]
osm_filenames = {
field: instance.json[field]
for field in fields if field in instance.json
}
for osm in osm_attachments:
osm_xml = osm.media_file.read()
filename = None
field_name = None
for k, v in osm_filenames.items():
if osm.filename.startswith(v.replace('.osm', '')):
filename = v
field_name = k
break
if field_name is None:
continue
filename = osm.filename if filename is None else filename
osm_list = parse_osm(osm_xml, include_osm_id=True)
for osmd in osm_list:
try:
osm_data = OsmData(
instance=instance,
xml=osm_xml,
osm_id=osmd['osm_id'],
osm_type=osmd['osm_type'],
tags=osmd['tags'],
geom=GeometryCollection(osmd['geom']),
filename=filename,
field_name=field_name)
osm_data.save()
except IntegrityError:
osm_data = OsmData.objects.get(
instance=instance, field_name=field_name)
osm_data.xml = osm_xml
osm_data.osm_id = osmd['osm_id']
osm_data.osm_type = osmd['osm_type']
osm_data.tags = osmd['tags']
osm_data.geom = GeometryCollection(osmd['geom'])
osm_data.filename = filename
osm_data.save()
instance.save()
trigger_webhook.send(sender=instance.__class__, instance=instance)
def test_collection_dims(self):
gc = GeometryCollection([])
self.assertEqual(gc.dims, -1)
gc = GeometryCollection(Point(0, 0))
self.assertEqual(gc.dims, 0)
gc = GeometryCollection(LineString((0, 0), (1, 1)), Point(0, 0))
self.assertEqual(gc.dims, 1)
gc = GeometryCollection(LineString((0, 0), (1, 1)), Polygon(((0, 0), (0, 1), (1, 1), (0, 0))), Point(0, 0))
self.assertEqual(gc.dims, 2)
def get_diff(self):
from django.contrib.gis.geos import Point, MultiPoint, LineString
from django.contrib.gis.geos import LinearRing, MultiLineString
from django.contrib.gis.geos import GeometryCollection
if self.field1 == self.field2:
return None
LINE_TYPES = [LineString, LinearRing, MultiLineString]
# Separate lines from other geometry in field1.
lines1, other_geom1 = self._split_out_geometry(LINE_TYPES, self.field1)
# Separate lines from other geometry in field2.
lines2, other_geom2 = self._split_out_geometry(LINE_TYPES, self.field2)
# For lines, we do an intersection() and then filter out point
# intersections.
lines_same = []
lines_intersection = lines1.intersection(lines2)
# Force to be a collection.
if not isinstance(lines_intersection, GeometryCollection):
lines_intersection = GeometryCollection(
lines_intersection, srid=lines_intersection.srid)
for geom in lines_intersection:
if type(geom) == Point or type(geom) == MultiPoint:
continue
lines_same.append(geom)
lines_same = GeometryCollection(lines_same, srid=self.field1.srid)
# The intersection of the other_geoms will tell us where
# they're the same.
other_geom_same = other_geom1.intersection(other_geom2)
# Force to be a collection. TODO: break out. Non-DRY.
if not isinstance(other_geom_same, GeometryCollection):
other_geom_same = GeometryCollection(other_geom_same,
srid=other_geom_same.srid)
# Form a collection out of the components of both.
same = GeometryCollection([g for g in other_geom_same] +
[g for g in lines_same],
srid=lines_same.srid)
deleted_other_geom = other_geom1.difference(other_geom2)
deleted_lines = lines1.difference(lines2)
inserted_other_geom = other_geom2.difference(other_geom1)
inserted_lines = lines2.difference(lines1)
deleted = deleted_other_geom.union(deleted_lines)
inserted = inserted_other_geom.union(inserted_lines)
return {'same': same, 'deleted': deleted, 'inserted': inserted}
def clean(self):
cleaned_data = super(GpxPoiForm, self).clean()
if 'gpx_file' in self.cleaned_data:
gpx_file = self.cleaned_data['gpx_file']
if gpx_file:
cleaned_data['geom'] = GeometryCollection(
gpx_parse.parse_gpx_filefield(gpx_file))
def _split_out_geometry(self, types, geoms):
from django.contrib.gis.geos import GeometryCollection
other_geom = []
split_out = []
if type(geoms) != GeometryCollection:
geoms = GeometryCollection(geoms, srid=geoms.srid)
for geom in geoms:
if type(geom) in types:
split_out.append(geom)
else:
other_geom.append(geom)
split_out = GeometryCollection(split_out, srid=geoms.srid)
other_geom = GeometryCollection(other_geom, srid=geoms.srid)
return (split_out, other_geom)
def test_srid(self):
"Testing the SRID property and keyword."
# Testing SRID keyword on Point
pnt = Point(5, 23, srid=4326)
self.assertEqual(4326, pnt.srid)
pnt.srid = 3084
self.assertEqual(3084, pnt.srid)
self.assertRaises(ctypes.ArgumentError, pnt.set_srid, '4326')
# Testing SRID keyword on fromstr(), and on Polygon rings.
poly = fromstr(self.geometries.polygons[1].wkt, srid=4269)
self.assertEqual(4269, poly.srid)
for ring in poly:
self.assertEqual(4269, ring.srid)
poly.srid = 4326
self.assertEqual(4326, poly.shell.srid)
# Testing SRID keyword on GeometryCollection
gc = GeometryCollection(Point(5, 23), LineString((0, 0), (1.5, 1.5), (3, 3)), srid=32021)
self.assertEqual(32021, gc.srid)
for i in range(len(gc)):
self.assertEqual(32021, gc[i].srid)
# GEOS may get the SRID from HEXEWKB
# 'POINT(5 23)' at SRID=4326 in hex form -- obtained from PostGIS
# using `SELECT GeomFromText('POINT (5 23)', 4326);`.
hex = '0101000020E610000000000000000014400000000000003740'
p1 = fromstr(hex)
self.assertEqual(4326, p1.srid)
p2 = fromstr(p1.hex)
self.assertIsNone(p2.srid)
p3 = fromstr(p1.hex, srid=-1) # -1 is intended.
self.assertEqual(-1, p3.srid)
def _map_merge(self, yours, theirs, ancestor):
"""
Merge yours and theirs. Return a conflict message if there was
a merge conflict.
"""
yours_added, yours_deleted = self._get_add_del(yours, ancestor)
theirs_added, theirs_deleted = self._get_add_del(theirs, ancestor)
# Look at the union of what was added + deleted in theirs and
# ours. If there's an overlap in these changes then we want to
# display a conflict message.
yours_changed = yours_added.union(yours_deleted)
theirs_changed = theirs_added.union(theirs_deleted)
has_conflict = yours_changed.intersects(theirs_changed)
# The merged material should be:
# our geometries + theirs that were added - theirs that were
# deleted *if* it wasn't already deleted in ours.
# We use str(geom) here because we want easy containment testing
# of geometries in sets.
yours_deleted_set = set([str(g) for g in yours_deleted])
merged = set([str(g) for g in yours] + [str(g) for g in theirs_added])
for geom in theirs_deleted:
if str(geom) not in yours_deleted_set:
merged.remove(str(geom))
merged_geom = GeometryCollection([GEOSGeometry(s) for s in merged],
srid=yours.srid)
return (merged_geom, has_conflict)
def get_layers(self):
layers = {}
if self.gpx.tracks:
layers['tracks'] = GeometryCollection(
MultiLineString(parse_tracks(self.gpx.tracks)))
if self.gpx.routes:
layers['routes'] = GeometryCollection(
MultiLineString(parse_routes(self.gpx.routes)))
if self.gpx.waypoints:
layers['waypoints'] = GeometryCollection(
MultiPoint(parse_waypoints(self.gpx.waypoints)))
if not layers:
raise InvalidGPXFile(
_("Error parsing GPX file: no geometry found."))
return layers
def make_geometrycollection_from_featurecollection(feature_collection):
geoms = []
features = ast.literal_eval(feature_collection)
for feature in features['features']:
feature_geom = feature['geometry']
geoms.append(GEOSGeometry(feature_geom))
return GeometryCollection(tuple(geoms))
def _fill_metadata_dataset_spatial_extent_form(data: dict, metadata: Metadata, dataset: Dataset, user: MrMapUser):
""" Fills form data into Metadata/Dataset records
Args:
data (dict): Cleaned form data
metadata (dict): The metadata record
dataset (dict): The dataset record
user: The performing user
Returns:
"""
try:
bounding_geometry = json.loads(data.get("bounding_geometry", "{}"))
except JSONDecodeError:
bounding_geometry = {}
if bounding_geometry.get("features", None) is not None:
# A list of features
geoms = [GEOSGeometry(str(feature["geometry"]), srid=DEFAULT_SRS) for feature in
bounding_geometry.get("features")]
geom = GeometryCollection(geoms, srid=DEFAULT_SRS).unary_union
elif bounding_geometry.get("feature", None) is not None:
geom = GEOSGeometry(str(bounding_geometry.get("feature")["geometry"]), srid=DEFAULT_SRS)
else:
try:
geom = GEOSGeometry(str(bounding_geometry), srid=DEFAULT_SRS)
except Exception:
# No features provided
return
metadata.bounding_geometry = geom
def setUp(self):
self.user = User.objects.create_user(username="******",
email="*****@*****.**",
password="******")
original_selection = GeometryCollection(
Point(1, 1), LineString((5.625, 48.458), (0.878, 44.339)))
extents = (-3.9, 16.1, 7.0, 27.6)
bbox = Polygon.from_bbox(extents)
the_geom = GEOSGeometry(bbox, srid=4326)
self.job = Job.objects.create(
name="TestJob",
event="Test Activation",
description="Test description",
user=self.user,
the_geom=the_geom,
original_selection=original_selection,
)
self.provider = DataProvider.objects.first()
self.parent_run = ExportRun.objects.create(job=self.job,
user=self.user,
is_cloning=False)
self.run = ExportRun.objects.create(job=self.job,
user=self.user,
is_cloning=True,
parent_run=self.parent_run)
def get_changelist_map(self, cl, request=None):
"""
Display a map in the admin changelist, with info popups
"""
if self.list_map:
info = []
if request:
qs = cl.get_query_set(request)
else:
qs = cl.get_query_set()
for obj in qs:
# Transform the fields into one projection.
geoms = []
for field in self.list_map:
geom = getattr(obj, field)
if geom:
if callable(geom):
geom = geom()
geoms.append(geom)
for geom in geoms:
geom.transform(int(DEFAULT_PROJ))
if geoms:
info.append((GeometryCollection(geoms,
srid=int(DEFAULT_PROJ)),
"<a href='%s'>%s</a>" %
(cl.url_for_result(obj), force_unicode(obj))))
return InfoMap(info, options=self.list_map_options)
return 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])
def setUp(self, ):
self.path = os.path.dirname(os.path.realpath(__file__))
self.group, created = Group.objects.get_or_create(
name='TestDefaultExportExtentGroup')
self.user1 = User.objects.create_user(username='******',
email='*****@*****.**',
password='******')
self.user2 = User.objects.create_user(username='******',
email='*****@*****.**',
password='******')
extents = (-3.9, 16.1, 7.0, 27.6)
bbox = Polygon.from_bbox(extents)
original_selection = GeometryCollection(
Point(1, 1), LineString((5.625, 48.458), (0.878, 44.339)))
the_geom = GEOSGeometry(bbox, srid=4326)
self.job = Job.objects.create(name='TestJob',
event='Test Activation',
description='Test description',
user=self.user1,
the_geom=the_geom,
original_selection=original_selection)
formats = ExportFormat.objects.all()
provider = DataProvider.objects.first()
provider_task = DataProviderTask.objects.create(provider=provider)
provider_task.formats.add(*formats)
self.job.provider_tasks.add(provider_task)
token = Token.objects.create(user=self.user1)
self.client.credentials(HTTP_AUTHORIZATION='Token ' + token.key,
HTTP_ACCEPT='application/json; version=1.0',
HTTP_ACCEPT_LANGUAGE='en',
HTTP_HOST='testserver')
# create a test config
hdm_presets = DatamodelPreset.objects.get(name='hdm')
self.job.preset = hdm_presets
self.job.save()
group1, created = Group.objects.get_or_create(name="group_one")
self.group1id = group1.id
gp = GroupPermission.objects.create(
group=group1,
user=self.user1,
permission=GroupPermissionLevel.ADMIN.value)
gp = GroupPermission.objects.create(
group=group1,
user=self.user2,
permission=GroupPermissionLevel.MEMBER.value)
group2, created = Group.objects.get_or_create(name="group_two")
self.group2id = group2.id
gp = GroupPermission.objects.create(
group=group2,
user=self.user1,
permission=GroupPermissionLevel.ADMIN.value)
gp = GroupPermission.objects.create(
group=group2,
user=self.user2,
permission=GroupPermissionLevel.MEMBER.value)
def get_geometry_from_string(geometry_string):
"""
Extract and convert the geometry from a (GeoJSON) string.
Args:
geometry_string: The geometry as (GeoJSON) string.
Returns:
A GeometryCollection or None.
"""
if geometry_string is None:
return None
try:
geometry_json = json.loads(geometry_string)
except json.decoder.JSONDecodeError:
return None
geoms = []
for feature in geometry_json.get('features', []):
try:
feature_geom = GEOSGeometry(
json.dumps(feature.get('geometry')))
except ValueError:
continue
except GDALException:
continue
geoms.append(feature_geom)
if geoms:
return GeometryCollection(tuple(geoms))
else:
return None
def __init__(self, service_url, layer, aoi_geojson=None, slug=None, max_area=0):
"""
Initialize this ProviderCheck object with a service URL and layer.
:param service_url: URL of provider, if applicable. Query string parameters are ignored.
:param layer: Layer or coverage to check for
:param aoi_geojson: (Optional) AOI to check for layer intersection
"""
self.service_url = service_url
self.query = None
self.layer = layer
self.slug = slug
self.max_area = max_area
self.result = CheckResults.SUCCESS
self.timeout = 10
self.verify = getattr(settings, "SSL_VERIFICATION", True)
if aoi_geojson is not None and aoi_geojson is not "":
if isinstance(aoi_geojson, str):
aoi_geojson = json.loads(aoi_geojson)
geoms = tuple([GEOSGeometry(json.dumps(feature.get('geometry')), srid=4326)
for feature in aoi_geojson.get('features')])
geom_collection = GeometryCollection(geoms, srid=4326)
logger.debug("AOI: {}".format(json.dumps(aoi_geojson)))
self.aoi = geom_collection
else:
self.aoi = None
logger.debug("AOI was not given")
self.token_dict = {} # Parameters to include in message field of response
def process_shapefile(tenant, layer_id, srs):
connection.close()
connection.set_schema(tenant)
l = Layer.objects.get(pk=layer_id)
shape_path = "%s/uploads/shapefile/%s/%s.shp" % (settings.MEDIA_ROOT,
tenant, l.pk)
try:
with fiona.open(shape_path, 'r') as collection:
count = 0
min_bounds = OGRGeometry('POINT ({} {})'.format(
collection.bounds[0], collection.bounds[1]),
srs=srs).transform(4326, clone=True)
max_bounds = OGRGeometry('POINT ({} {})'.format(
collection.bounds[2], collection.bounds[3]),
srs=srs).transform(4326, clone=True)
l.bounds = min_bounds.coords + max_bounds.coords
features = []
for index, record in enumerate(collection):
try:
geom = shape(record['geometry'])
transformed_geom = OGRGeometry(
geom.wkt, srs=srs).transform(3857, clone=True)
transformed_geom_collection = GeometryCollection(
transformed_geom.geos)
s = hashlib.sha1()
s.update(transformed_geom_collection.ewkb)
properties = record['properties']
properties['fid'] = index
properties['shaid'] = s.hexdigest()
features.append(
Feature(layer=l,
geometry=transformed_geom_collection,
properties=properties))
count += 1
except Exception as e:
print "Feature excepton", e
if count == 0:
raise Exception("Layer needs to have at least one feature")
Feature.objects.bulk_create(features)
field_names = collection.schema['properties'].keys()
field_names.append("fid")
l.field_names = field_names
l.properties = collection.schema['properties']
l.schema = collection.schema
l.status = 0
l.save()
finally:
for path in glob.glob("%s/uploads/shapefile/%s/%s.*" %
(settings.MEDIA_ROOT, tenant, l.pk)):
os.remove(path)
def process_feature_geoms(self,
properties,
resource,
geo_process="collection"):
geoms = []
result = None
for g in resource["_source"]["geometries"]:
geom = GEOSGeometry(JSONSerializer().serialize(g["value"],
ensure_ascii=False))
geoms.append(geom)
if geo_process == "collection":
geometry = GeometryCollection(geoms)
result = {
"type": "Feature",
"geometry": geometry,
"properties": properties
}
elif geo_process == "sorted":
result = []
sorted_geoms = {"points": [], "lines": [], "polys": []}
for geom in geoms:
if geom.geom_typeid == 0:
sorted_geoms["points"].append(geom)
if geom.geom_typeid == 1:
sorted_geoms["lines"].append(geom)
if geom.geom_typeid == 3:
sorted_geoms["polys"].append(geom)
if geom.geom_typeid == 4:
for feat in geom:
sorted_geoms["points"].append(feat)
if geom.geom_typeid == 5:
for feat in geom:
sorted_geoms["lines"].append(feat)
if geom.geom_typeid == 6:
for feat in geom:
sorted_geoms["polys"].append(feat)
if len(sorted_geoms["points"]) > 0:
result.append({
"type": "Feature",
"geometry": MultiPoint(sorted_geoms["points"]),
"properties": properties,
})
if len(sorted_geoms["lines"]) > 0:
result.append({
"type":
"Feature",
"geometry":
MultiLineString(sorted_geoms["lines"]),
"properties":
properties,
})
if len(sorted_geoms["polys"]) > 0:
result.append({
"type": "Feature",
"geometry": MultiPolygon(sorted_geoms["polys"]),
"properties": properties,
})
return result
def process_feature_geoms(self,
properties,
resource,
geo_process='collection'):
geoms = []
result = None
for g in resource['_source']['geometries']:
geom = GEOSGeometry(JSONSerializer().serialize(g['value'],
ensure_ascii=False))
geoms.append(geom)
if geo_process == 'collection':
geometry = GeometryCollection(geoms)
result = {
'type': 'Feature',
'geometry': geometry,
'properties': properties
}
elif geo_process == 'sorted':
result = []
sorted_geoms = {'points': [], 'lines': [], 'polys': []}
for geom in geoms:
if geom.geom_typeid == 0:
sorted_geoms['points'].append(geom)
if geom.geom_typeid == 1:
sorted_geoms['lines'].append(geom)
if geom.geom_typeid == 3:
sorted_geoms['polys'].append(geom)
if geom.geom_typeid == 4:
for feat in geom:
sorted_geoms['points'].append(feat)
if geom.geom_typeid == 5:
for feat in geom:
sorted_geoms['lines'].append(feat)
if geom.geom_typeid == 6:
for feat in geom:
sorted_geoms['polys'].append(feat)
if len(sorted_geoms['points']) > 0:
result.append({
'type': 'Feature',
'geometry': MultiPoint(sorted_geoms['points']),
'properties': properties
})
if len(sorted_geoms['lines']) > 0:
result.append({
'type':
'Feature',
'geometry':
MultiLineString(sorted_geoms['lines']),
'properties':
properties
})
if len(sorted_geoms['polys']) > 0:
result.append({
'type': 'Feature',
'geometry': MultiPolygon(sorted_geoms['polys']),
'properties': properties
})
return result
def get_layers(self):
layers = {}
for layer in self.ds:
name = layer.name
if name in KEEP_LAYERS:
# geom = self._get_features(layer)
layers[name] = GeometryCollection(layer.get_geoms(geos=True))
return layers
class GeometryCollectionFieldDefinitionTest(GeometryFieldDefinitionTestMixin,
BaseModelDefinitionTestCase):
field_definition_cls_name = 'GeometryCollectionFieldDefinition'
field_values = (
GeometryCollection(
Point(0, 0),
Polygon(((0.0, 0.0), (18, 50.0), (47.0, 55.0), (50.0, 0.0),
(0.0, 0.0))),
),
GeometryCollection(
LineString((1, 2), (3, 4), (5, 6), (7, 8), (9, 10)),
Polygon(((0.0, 0.0), (18, 50.0), (47.0, 55.0), (50.0, 0.0),
(0.0, 0.0))),
Point(5, 23),
Point(13, 37),
),
)
def geo_data(apps, schema_editor):
Project = apps.get_model("projects", "Project")
projects = Project.objects.all()
for project in projects:
if project.coordonnees_geographiques is not '':
geom = GEOSGeometry(project.coordonnees_geographiques)
project.coordonnees_geogrpahiques_gis = GeometryCollection(geom)
project.save()
def make_geometrycollection_from_featurecollection(self,
feature_collection):
geoms = []
features = json.loads(feature_collection)
for feature in features['features']:
feature_geom = json.dumps(feature['geometry'])
geoms.append(GEOSGeometry(feature_geom))
return GeometryCollection(tuple(geoms))
def test_unary_union(self):
"Testing unary_union."
for i in range(len(self.geometries.topology_geoms)):
a = fromstr(self.geometries.topology_geoms[i].wkt_a)
b = fromstr(self.geometries.topology_geoms[i].wkt_b)
u1 = fromstr(self.geometries.union_geoms[i].wkt)
u2 = GeometryCollection(a, b).unary_union
self.assertTrue(u1.equals(u2))
class PermitRequestGeoTimeFactory(factory.django.DjangoModelFactory):
class Meta:
model = models.PermitRequestGeoTime
permit_request = factory.SubFactory(PermitRequestFactory)
starts_at = factory.Faker("date_time", tzinfo=timezone.utc)
ends_at = factory.Faker("date_time", tzinfo=timezone.utc)
geom = factory.LazyFunction(
lambda: GeometryCollection(Point(faker.Faker().latlng())))
def geom(self):
""" Merge all interventions geometry into a collection
"""
if self._geom is None:
interventions = Intervention.objects.existing().filter(project=self)
geoms = [i.geom for i in interventions if i.geom is not None]
if geoms:
self._geom = GeometryCollection(*geoms, srid=settings.SRID)
return self._geom
def geomfield(cls):
from django.contrib.gis.geos import LineString
# Fake field, TODO: still better than overkill code in views, but can do neater.
c = GeometryCollection([LineString((0, 0), (1, 1))], srid=settings.SRID)
c.name = 'geom'
return c
