def test_related_extent_annotate(self):
"""
Test annotation with Extent GeoAggregate.
"""
cities = City.objects.annotate(
points_extent=Extent("location__point")).order_by("name")
tol = 4
self.assertAlmostEqual(cities[0].points_extent,
(-97.516111, 33.058333, -97.516111, 33.058333),
tol)
def map_extent_as_json(self):
feature_extent = self.mapfeature_set \
.aggregate(Extent('geom'))['geom__extent']
bounds_extent = self.bounds_extent
if feature_extent is not None:
intersection = extent_intersection(feature_extent, bounds_extent)
return extent_as_json(intersection)
return extent_as_json(bounds_extent)
def test_extent(self):
"""
Testing the (deprecated) `extent` GeoQuerySet method and the Extent
aggregate.
"""
# Reference query:
# `SELECT ST_extent(point) FROM geoapp_city WHERE (name='Houston' or name='Dallas');`
# => BOX(-96.8016128540039 29.7633724212646,-95.3631439208984 32.7820587158203)
expected = (-96.8016128540039, 29.7633724212646, -95.3631439208984, 32.782058715820)
qs = City.objects.filter(name__in=('Houston', 'Dallas'))
extent1 = qs.extent()
extent2 = qs.aggregate(Extent('point'))['point__extent']
for extent in (extent1, extent2):
for val, exp in zip(extent, expected):
self.assertAlmostEqual(exp, val, 4)
self.assertIsNone(City.objects.filter(name=('Smalltown')).extent())
self.assertIsNone(City.objects.filter(name=('Smalltown')).aggregate(Extent('point'))['point__extent'])
def _get_bounding_box(self):
queryset = self._get_unsorted_undistinct_queryset()
extent = queryset.aggregate(Extent("geom"))["geom__extent"]
if extent is None:
extent = settings.ENHYDRIS_MAP_DEFAULT_VIEWPORT[:]
extent = list(extent)
ensure_extent_is_large_enough(extent)
return extent
def test_related_extent_aggregate(self):
"Testing the `Extent` aggregate on related geographic models."
# This combines the Extent and Union aggregates into one query
aggs = City.objects.aggregate(Extent("location__point"))
# One for all locations, one that excludes New Mexico (Roswell).
all_extent = (-104.528056, 29.763374, -79.460734, 40.18476)
txpa_extent = (-97.516111, 29.763374, -79.460734, 40.18476)
e1 = City.objects.aggregate(
Extent("location__point"))["location__point__extent"]
e2 = City.objects.exclude(state="NM").aggregate(
Extent("location__point"))["location__point__extent"]
e3 = aggs["location__point__extent"]
# The tolerance value is to four decimal places because of differences
# between the Oracle and PostGIS spatial backends on the extent calculation.
tol = 4
for ref, e in [(all_extent, e1), (txpa_extent, e2), (all_extent, e3)]:
for ref_val, e_val in zip(ref, e):
self.assertAlmostEqual(ref_val, e_val, tol)
def collection_collect_metadata(collection,
collect_footprint=True,
collect_begin_time=True,
collect_end_time=True,
product_summary=False,
coverage_summary=False,
use_extent=False):
""" Collect metadata
"""
if collect_footprint or collect_begin_time or collect_end_time:
aggregates = {}
if collect_footprint:
if use_extent:
aggregates["extent"] = Extent("footprint")
else:
aggregates["footprint"] = Union("footprint")
if collect_begin_time:
aggregates["begin_time"] = Min("begin_time")
if collect_end_time:
aggregates["end_time"] = Max("end_time")
values = EOObject.objects.filter(
Q(coverage__collections=collection)
| Q(product__collections=collection)).aggregate(**aggregates)
if collect_footprint:
if use_extent:
collection.footprint = Polygon.from_bbox(values["extent"])
else:
collection.footprint = values["footprint"]
if collect_begin_time:
collection.begin_time = values["begin_time"]
if collect_end_time:
collection.end_time = values["end_time"]
if product_summary or coverage_summary:
collection_metadata, _ = CollectionMetadata.objects.get_or_create(
collection=collection)
if product_summary:
collection_metadata.product_metadata_summary = json.dumps(
_collection_metadata(collection, ProductMetadata, 'product'),
indent=4,
sort_keys=True)
if coverage_summary:
collection_metadata.coverage_metadata_summary = json.dumps(
_collection_metadata(collection, CoverageMetadata, 'coverage'),
indent=4,
sort_keys=True)
collection_metadata.save()
def get_context_data(self, **kwargs):
context = super(CWTSequenceDetail, self).get_context_data(**kwargs)
cwt_number = self.kwargs.get("cwt_number")
context["cwt_number"] = cwt_number
context["cwts"] = CWT.objects.filter(cwt_number=cwt_number)
events = StockingEvent.objects.filter(
cwt_series__cwt__cwt_number=cwt_number)
event_points = [(x[0], x[1].x, x[1].y)
for x in events.values_list("stock_id", "geom")]
context["event_points"] = event_points
extent = events.aggregate(bbox=Extent("jurisdiction__lake__geom"))
if extent:
context["bbox"] = extent["bbox"]
else:
extent = Lake.objects.aggregate(bbox=Extent(Extent("geom")))
context["bbox"] = extent["bbox"]
return context
def extent(self, srid=None):
"""Returns the GeoQuerySet extent as a 4-tuple.
Keyword args:
srid -- EPSG id for for transforming the output geometry.
"""
fieldname = self.geo_field.name
ext = Extent(fieldname)
key = '%s__extent' % fieldname
clone = self.all()
qs = clone.transform(srid) if srid else clone
return qs.aggregate(ext)[key]
def operator_map(request, slug):
operator = get_object_or_404(Operator.objects.select_related('region'),
slug=slug)
services = operator.service_set.filter(current=True)
extent = services.aggregate(Extent('geometry'))['geometry__extent']
if not extent:
extent = operator.vehicle_set.aggregate(
Extent('latest_location__latlong')
)['latest_location__latlong__extent']
if not extent:
raise Http404
return render(
request, 'operator_map.html', {
'object': operator,
'operator': operator,
'breadcrumb': [operator.region, operator],
'operator_id': operator.id,
'extent': extent
})
def get_bounding_box(self) -> Optional[BoundingBox]:
"""Returns a WGS84 BoundingBox for the complete feature.
This is used by the GetCapabilities request. It may return ``None``
when the database table is empty, or the custom queryset doesn't
return any results.
"""
geo_expression = conditional_transform(self.geometry_field.name,
self.geometry_field.srid,
WGS84.srid)
bbox = self.get_queryset().aggregate(a=Extent(geo_expression))["a"]
return BoundingBox(*bbox, crs=WGS84) if bbox else None
def handle(self, *args, **options):
for layer in Layer.objects.all():
if options['verbosity'] >= 1:
self.stdout.write(f'Generating {layer.name} tiles cache')
bbox = layer.features.aggregate(bbox=Extent('geom'))['bbox']
if bbox:
vtile = VectorTile(layer)
zoom_range = range(
layer.layer_settings_with_default('tiles', 'minzoom'),
layer.layer_settings_with_default('tiles', 'maxzoom') + 1)
for tile in tiles(*bbox, zoom_range):
vtile.get_tile(tile.x, tile.y, tile.z)
def getActivityExtent(self, start_datetime, end_datetime):
'''
Get spatial temporal extent for a platform.
'''
qs = Activity.objects.using(
self.database).filter(platform__name__in=self.platformName)
qs = qs.filter(startdate__gte=start_datetime)
qs = qs.filter(enddate__lte=end_datetime)
seaQS = qs.aggregate(Min('startdate'), Max('enddate'))
self.activityStartTime = seaQS['startdate__min']
self.activityEndTime = seaQS['enddate__max']
dataExtent = qs.aggregate(Extent('maptrack'))
return dataExtent
def test04_related_aggregate(self):
"Testing the `extent` and `unionagg` GeoQuerySet aggregates on related geographic models."
# This combines the Extent and Union aggregates into one query
aggs = City.objects.aggregate(Extent('location__point'),
Union('location__point'))
# One for all locations, one that excludes Roswell.
all_extent = (-104.528060913086, 33.0583305358887, -79.4607315063477,
40.1847610473633)
txpa_extent = (-97.51611328125, 33.0583305358887, -79.4607315063477,
40.1847610473633)
e1 = City.objects.extent(field_name='location__point')
e2 = City.objects.exclude(name='Roswell').extent(
field_name='location__point')
e3 = aggs['location__point__extent']
# The tolerance value is to four decimal places because of differences
# between the Oracle and PostGIS spatial backends on the extent calculation.
tol = 4
for ref, e in [(all_extent, e1), (txpa_extent, e2), (all_extent, e3)]:
for ref_val, e_val in zip(ref, e):
self.assertAlmostEqual(ref_val, e_val, tol)
# These are the points that are components of the aggregate geographic
# union that is returned.
p1 = Point(-104.528056, 33.387222)
p2 = Point(-97.516111, 33.058333)
p3 = Point(-79.460734, 40.18476)
# Creating the reference union geometry depending on the spatial backend,
# as Oracle will have a different internal ordering of the component
# geometries than PostGIS. The second union aggregate is for a union
# query that includes limiting information in the WHERE clause (in other
# words a `.filter()` precedes the call to `.unionagg()`).
if SpatialBackend.oracle:
ref_u1 = MultiPoint(p3, p1, p2, srid=4326)
ref_u2 = MultiPoint(p3, p2, srid=4326)
else:
ref_u1 = MultiPoint(p1, p2, p3, srid=4326)
ref_u2 = MultiPoint(p2, p3, srid=4326)
u1 = City.objects.unionagg(field_name='location__point')
u2 = City.objects.exclude(name='Roswell').unionagg(
field_name='location__point')
u3 = aggs['location__point__union']
self.assertEqual(ref_u1, u1)
self.assertEqual(ref_u2, u2)
self.assertEqual(ref_u1, u3)
def test_extent(self):
"""
Testing the `Extent` aggregate.
"""
# Reference query:
# SELECT ST_extent(point)
# FROM geoapp_city
# WHERE (name='Houston' or name='Dallas');`
# => BOX(-96.8016128540039 29.7633724212646,-95.3631439208984 32.7820587158203)
expected = (
-96.8016128540039,
29.7633724212646,
-95.3631439208984,
32.782058715820,
)
qs = City.objects.filter(name__in=("Houston", "Dallas"))
extent = qs.aggregate(Extent("point"))["point__extent"]
for val, exp in zip(extent, expected):
self.assertAlmostEqual(exp, val, 4)
self.assertIsNone(
City.objects.filter(name=("Smalltown")).aggregate(
Extent("point"))["point__extent"])
def GeometryBounds(request):
"""
Get bounds of particular area
"""
data = json.loads(request.body)
area = Geometry.objects.filter(zoom=15, code=data['areacode']).annotate(
Extent('geometry')).values('type', 'geometry__extent').first()
geometrytype = 1 + geometrytypecode.index(area['type'])
return HttpResponse(json.dumps({
'geometrytype': geometrytype,
'rect': area['geometry__extent']
}),
content_type="text/json")
def index(request):
query = models.Marker.objects.order_by('-id')
maybe_extent = query.aggregate(Extent('location'))['location__extent']
if maybe_extent:
lower_left_lat, lower_left_lng, upper_right_lat, upper_right_lng = maybe_extent
extent_points = [[lower_left_lat, lower_left_lng], [upper_right_lat, upper_right_lng]]
else:
extent_points = INDIA_EXTENT
markers = [{'id': marker.id,
'location': {'lat': marker.location.x, 'lng': marker.location.y}, # Yes, this is inverted
'name': marker.name}
for marker in query]
return render(request,
'app/home.html',
{'page_title': 'All Markers',
'js_constants': {'markers': markers, 'extent_points': extent_points}})
def test04a_related_extent_aggregate(self):
"Testing the `extent` GeoQuerySet aggregates on related geographic models."
# This combines the Extent and Union aggregates into one query
aggs = City.objects.aggregate(Extent('location__point'))
# One for all locations, one that excludes Roswell.
all_extent = (-104.528060913086, 33.0583305358887,-79.4607315063477, 40.1847610473633)
txpa_extent = (-97.51611328125, 33.0583305358887,-79.4607315063477, 40.1847610473633)
e1 = City.objects.extent(field_name='location__point')
e2 = City.objects.exclude(name='Roswell').extent(field_name='location__point')
e3 = aggs['location__point__extent']
# The tolerance value is to four decimal places because of differences
# between the Oracle and PostGIS spatial backends on the extent calculation.
tol = 4
for ref, e in [(all_extent, e1), (txpa_extent, e2), (all_extent, e3)]:
for ref_val, e_val in zip(ref, e): self.assertAlmostEqual(ref_val, e_val, tol)
def get_map_url(geo_times, permit_id):
"""Docstring:
"""
extent = list(geo_times.aggregate(Extent('geom'))['geom__extent'])
buffer_extent = int(os.environ["PRINT_MAP_BUFFER_METERS"])
h_extent_left = round(extent[0] - buffer_extent)
h_extent_right = round(extent[2] + buffer_extent)
v_extent_bottom = round(extent[1] - buffer_extent)
v_extent_top = round(extent[3] + buffer_extent)
extent = [h_extent_left, v_extent_bottom, h_extent_right, v_extent_top]
if settings.PRINTED_REPORT_LAYERS == "":
layers = 'permit_permitrequestgeotime_polygons,permit_permitrequestgeotimes_lines,permit_permitrequestgeotime_points'
else:
layers = settings.PRINTED_REPORT_LAYERS
values = {
'SERVICE':
'WMS',
'VERSION':
'1.3.0',
'REQUEST':
'GetPrint',
'FORMAT':
'png',
'TRANSPARENT':
'true',
'SRS':
'EPSG:2056',
'DPI':
'150',
'TEMPLATE':
'permits',
'map0:extent':
', '.join(map(str, extent)),
'LAYERS':
layers,
'FILTER':
'permits_permitrequestgeotime_polygons,permits_permitrequestgeotimes_lines,permits_permitrequestgeotime_points:"permit_request_id" > '
+ str(permit_id - 1) + ' AND "permit_request_id" < ' +
str(permit_id + 1)
}
data = urllib.parse.urlencode(values)
printurl = "http://qgisserver" + '/?' + data
return printurl
def get_extents(self):
for operator in (
'SBAY',
'CBUS',
'CUBU',
'ECWY',
'FALC',
'GECL',
'GAHL',
'guernsey',
'HIPK',
'IPSW',
'LYNX',
'MDCL',
'NDTR',
'DPCE',
'RBUS',
'NADS',
'SFGC',
'SESX',
'NIBS',
'UNOE',
'WHTL',
'TRDU',
# 'ROST',
):
stops = StopPoint.objects.filter(service__operator=operator, service__current=True)
extent = stops.aggregate(Extent('latlong'))['latlong__extent']
if not extent:
print(operator)
continue
yield {
'maxLat': extent[3] + 0.1,
'maxLng': extent[2] + 0.1,
'minLat': extent[1] - 0.1,
'minLng': extent[0] - 0.1,
}
# Mann
yield {
'maxLat': 54.5,
'maxLng': -3.8,
'minLat': 53.9,
'minLng': -5.1
}
def _describe(self, request, base_url):
# retrieve the key under which this viewset was registered in the wfs3 router
key = None
for prefix, viewset, basename in wfs3_router.registry:
if viewset is self.__class__:
key = prefix
break
else:
raise Exception(f"Did not find {self} in {wfs3_router.registry}")
# retrieve wfs3 config defined on the viewset
title = getattr(self, "wfs3_title", f"Layer {key}")
description = getattr(self, "wfs3_description", "No description")
srid = getattr(self, "wfs3_srid", 4326)
extents = self.get_queryset().aggregate(e=Extent(self.wfs3_geom_lookup))["e"]
# return the wfs3 layer description as an object
return {
"id": key,
"title": title,
"description": description,
"extent": {
"spatial": {
"bbox": [extents],
"crs": f"http://www.opengis.net/def/crs/EPSG/0/{srid}", # seems this isn't recognized by QGIS ?
},
},
"crs": [
f"http://www.opengis.net/def/crs/EPSG/0/{srid}", # seems this isn't recognized by QGIS ?
],
"links": [
{
"href": request.build_absolute_uri(f"{base_url}{key}"),
"rel": "self",
"type": "application/geo+json",
"title": "This document as JSON",
},
{
"href": request.build_absolute_uri(f"{base_url}{key}/items"),
"rel": "items",
"type": "application/geo+json",
"title": key,
},
],
}
def get_bounding_box(self):
min_x, min_y, max_x, max_y = 1e9, 1e9, -1e9, -1e9
for model in get_all_geomodels():
extent = model.objects.filter(
name__unaccent__icontains=self.search_term).aggregate(
Extent("geom2100"))["geom2100__extent"]
if not extent:
continue
min_x = min(min_x, extent[0])
min_y = min(min_y, extent[1])
max_x = max(max_x, extent[2])
max_y = max(max_y, extent[3])
if (min_x, min_y, max_x, max_y) == (1e9, 1e9, -1e9, -1e9):
return settings.ENHYDRIS_MAP_DEFAULT_VIEWPORT[:]
extent = [min_x, min_y, max_x, max_y]
self.transform_extent_to_wgs84(extent)
ensure_extent_is_large_enough(extent)
return extent
def get(self, request, *args):
_uuid = 'Not found'
try:
user_id = -1
if request.user.is_authenticated:
user_id = request.user.id
_uuid = UserUUID.objects.get(user_id=user_id).uuid
if request.user.is_staff:
try:
_uuid = UserUUID.objects.get(user_id=0).uuid
except UserUUID.DoesNotExist:
pass
except UserUUID.DoesNotExist:
pass
wells = WellWithUUID.objects.filter(Q(uuid=_uuid)
| Q(public=True)).aggregate(
Extent('location'))
return Response({'uuid': _uuid, 'extent': wells['location__extent']})
def get_boxes(self):
geojson = {"type": "FeatureCollection", "features": []}
i = 0
operators = Operator.objects.filter(name__startswith='Stagecoach', service__current=True, vehicle_mode='bus')
operators = operators.exclude(service__servicecode__scheme__endswith=' SIRI',
service__tracking=True).using('read-only')
services = Service.objects.filter(operator__in=operators).using('read-only')
extent = services.aggregate(Extent('geometry'))['geometry__extent']
lng = extent[0]
while lng <= extent[2]:
lat = extent[1]
while lat <= extent[3]:
bbox = (
lng,
lat,
lng + 1.5,
lat + 1,
)
polygon = Polygon.from_bbox(bbox)
i += 1
if services.filter(geometry__bboverlaps=polygon).exists():
geojson['features'].append({
"type": "Feature",
"geometry": json.loads(polygon.json),
"properties": {
"name": str(i)
}
})
yield {
'latne': bbox[3],
'lngne': bbox[2],
'latsw': bbox[1],
'lngsw': bbox[0],
# 'clip': 1,
# 'descriptive_fields': 1
}
lat += 1
lng += 1.5
print(json.dumps(geojson))
def _getActivityExtent(self, platform=None):
'''
Get details of the Activities that the platform(s) ha{s,ve}. Set those details to member variables and
also return them as a tuple. Polymorphic: if platform is a list or tuple return spatial temporal
extent for all of the platforms.
'''
# Get start and end datetimes, color and geographic extent of the activity
# If multiple platforms use them all to get overall start & end times and extent and se tcolor to black
if platform:
if isinstance(platform, list) or isinstance(platform, tuple):
aQS = Activity.objects.using(
self.args.database).filter(platform__name__in=platform)
else:
aQS = Activity.objects.using(
self.args.database).filter(platform__name=platform)
else:
aQS = Activity.objects.using(self.args.database).all()
seaQS = aQS.aggregate(Min('startdate'), Max('enddate'))
self.activityStartTime = seaQS['startdate__min']
self.activityEndTime = seaQS['enddate__max']
self.dataExtent = aQS.aggregate(Extent('maptrack'))['maptrack__extent']
# Expand the computed extent by extendDeg degrees
allExtent = self.dataExtent
try:
if self.args.extend:
extendDeg = self.args.extend
allExtent = (allExtent[0] - extendDeg,
allExtent[1] - extendDeg,
allExtent[2] + extendDeg,
allExtent[3] + extendDeg)
# Override with extent if specified on command line
if self.args.extent:
allExtent = [float(e) for e in self.args.extent]
except AttributeError:
# Likely not specified on the command line, just ignore
pass
return self.activityStartTime, self.activityEndTime, allExtent
def infoOnMap(request, id):
square = Node.objects.filter(fileInfo_id=id).aggregate(Extent('GPS', geo_field_type=GeometryField))
ext=square['GPS__extent']
mp=MultiPoint(Point(ext[1::-1]),Point(ext[3:1:-1]))
nodes = Node.objects.filter(fileInfo_id=id).order_by('dateTimeLabel')
points = []
props=[]
chartData=[]
for node in nodes:
points.append(Point(node.GPS.y,node.GPS.x))
print()
d={}
cd={}
d['CO']=node.CO
d['NO2']=node.NO2
d['TEMP']=node.TEMP
props.append(d)
cd['dateTimeLabel']=node.dateTimeLabel.strftime('%Y-%m-%dT%H:%M:%S.%f')
cd['dist']=node.dist
cd['TEMP']=node.TEMP
cd['CO']=node.CO
cd['NO2']=node.NO2
chartData.append(cd)
mps=MultiPoint(points)
# print(mps.json)
return render(request, 'map.html', {
'extent': mp.json,
'points': mps.json,
'props': props,
'chartData': chartData,
})
def ExtentView(request):
valuecode = request.GET.get('valuecode')
tojson = incidentReports.objects.filter(id=valuecode).aggregate(
Extent('geom')).get('geom__extent')
return JsonResponse(tojson, safe=False)
# class incidentReportsViewSet(viewsets.ModelViewSet):
# queryset = incidentReports.objects.all()
# serializer_class = incidentReportsSerializer
# # filter_backends = (filters.OrderingFilter ,filters.SearchFilter)
# # filter_fields = ('report',)
# ordering =('-id',)
# # search_fields = ('longitude','latitude','report_type')
# class incidentReportsViewSet(viewsets.ModelViewSet):
# """
# API endpoint that allows users to be viewed or edited.
# """
# queryset = incidentReports.objects.all().order_by('-created_date')
# serializer_class = incidentReportsSerializer
# @api_view(['GET', 'POST'])
# def incidentReportsView(request):
# """
# List all code snippets, or create a new snippet.
# """
# if request.method == 'GET':
# incident = incidentReports.objects.all()
# serializer = incidentReportsSerializer(incident, many=True)
# return Response(serializer.data)
# elif request.method == 'POST':
# serializer = incidentReportsSerializer(data=request.data)
# if serializer.is_valid():
# serializer.save()
# return Response(serializer.data, status=status.HTTP_201_CREATED)
# return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def get_boxes(self):
# geojson = {"type": "FeatureCollection", "features": []}
i = 0
operators = Operator.objects.filter(parent='Stagecoach',
service__current=True,
vehicle_mode='bus')
services = Service.objects.filter(operator__in=operators)
extent = services.aggregate(Extent('geometry'))['geometry__extent']
lng = extent[0]
while lng <= extent[2]:
lat = extent[1]
while lat <= extent[3]:
bbox = (
lng,
lat,
lng + 1.5,
lat + 1,
)
polygon = Polygon.from_bbox(bbox)
i += 1
if services.filter(geometry__bboverlaps=polygon).exists():
# geojson['features'].append({
# "type": "Feature",
# "geometry": json.loads(polygon.json),
# "properties": {
# "name": str(i)
# }
# })
yield {
'latne': bbox[3],
'lngne': bbox[2],
'latsw': bbox[1],
'lngsw': bbox[0],
# 'clip': 1,
# 'descriptive_fields': 1
}
lat += 1
lng += 1.5
def get_items(self):
for opco in self.opcos:
for operator in self.opcos[opco]:
stops = StopPoint.objects.filter(service__operator=operator, service__current=True)
extent = stops.aggregate(Extent('latlong'))
stops = stops.filter(stopusageusage__datetime__lt=self.source.datetime + timedelta(minutes=5),
stopusageusage__datetime__gt=self.source.datetime - timedelta(hours=1),
stopusageusage__journey__service__operator=operator)
for lng, lat in self.get_bounding_boxes(extent):
bbox = Polygon.from_bbox(
(lng - 0.1, lat - 0.1, lng + 0.1, lat + 0.1)
)
if stops.filter(latlong__within=bbox).exists():
params = {'lat': lat, 'lng': lng}
headers = {'opco': opco}
try:
response = self.session.get(self.url, params=params, timeout=30, headers=headers)
for item in response.json()['data']:
yield item
except (RequestException, KeyError):
continue
sleep(1)
def getlargestpolygon(areatype):
"""
Get largest area for particular area type
Ad-hoc function used to determine minimum zoom levels when MSOA/IG and LSOA/DZ appear
"""
maxvalue = 0
areacode = ''
geometries = Geometry.objects.filter(zoom=15, type=areatype).annotate(
Extent('geometry')).values('code', 'geometry__extent')
for geometry in geometries:
lng_west, lat_south, lng_east, lat_north = geometry['geometry__extent']
lat_dif = lat_north - lat_south
lng_dif = lng_east - lng_west
if (lng_dif > maxvalue):
maxvalue = lng_dif
areacode = geometry['code']
if (lat_dif > maxvalue):
maxvalue = lat_dif
areacode = geometry['code']
return areacode
def _get_project_geoareas(project):
qs = GeoArea.objects.filter(
admin_level__region__in=project.regions.values_list('id'),
admin_level__level__in=[0, 1, 2],
).annotate(extent=Extent('polygons')).values('pk', 'admin_level__level',
'title', 'polygons', 'extent',
'parent')
geo_array = []
for geoarea in qs:
polygons = geoarea['polygons']
centroid = polygons.centroid
geo = {
'id': geoarea['pk'],
'admin_level': geoarea['admin_level__level'],
'parent': geoarea['parent'],
'name': geoarea['title'],
'centroid': [centroid.x, centroid.y],
'bounds': [geoarea['extent'][:2], geoarea['extent'][2:]],
}
geo['polygons'] = json.loads(polygons.geojson) # TODO:
geo_array.append(geo)
return geo_array