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 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 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 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 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 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 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 __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 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 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 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 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 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))
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 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
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 get_geometry(item): if 'Polygoon' in item: polygon = item['Polygoon'] if type(polygon) == list: functional_errors.append( 'Object has more than one Polygon: {}'.format(item['Id'])) polygon = polygon[0] gm = GEOSGeometry(polygon) if gm.geom_type == 'GeometryCollection': return gm geometry = GeometryCollection(gm) elif 'Punt' in item and type(item['Punt']) == list: geometry = GeometryCollection() for p in item['Punt']: geometry.append(GEOSGeometry(p)) else: geometry = None return geometry