def city_from_extent(extent):
city_extents = dict([(m['short_name'], m['extent']) for m in METRO_LIST])
env = OGRGeometry(Envelope(*extent).wkt)
matches = []
for slug, city_ext in city_extents.iteritems():
city_env = OGRGeometry(Envelope(*city_ext).wkt)
if city_env.intersects(env):
matches.append((slug, city_env))
if len(matches) == 1:
return matches[0][0]
elif len(matches) > 1:
# Crudely select the intersecting city with the most overlap
# TODO: get rid of this
current_best_slug, current_max_area = None, float('-inf')
for slug, city_env in matches:
intersection = city_env.intersection(env)
area = intersection.area
if area > current_max_area:
current_max_area = area
current_best_slug = slug
return current_best_slug
# If we didn't find a match with a city extent, start expanding the buffer
# around the city extents until we match one
for i in xrange(6):
for slug, city_ext in city_extents.iteritems():
extent = buffer_extent(city_ext, 1, num_tiles=i + 1)
city_env = OGRGeometry(Envelope(*extent).wkt)
if env.intersects(city_env):
return slug
def get(self, request, admin_level_id, version=None):
if not AdminLevel.objects.filter(id=admin_level_id).exists():
raise exceptions.NotFound()
admin_level = AdminLevel.objects.get(id=admin_level_id)
if not admin_level.can_get(request.user):
raise exceptions.PermissionDenied()
areas = admin_level.geoarea_set.filter(polygons__isnull=False)
if areas.count() > 0:
try:
envelope = Envelope(*areas[0].polygons.extent)
for area in areas[1:]:
envelope.expand_to_include(*area.polygons.extent)
return response.Response({
'bounds': {
'min_x': envelope.min_x,
'min_y': envelope.min_y,
'max_x': envelope.max_x,
'max_y': envelope.max_y,
}
})
except ValueError as e:
return response.Response({
'bounds': None,
})
return response.Response({
'bounds': None,
})
def test01_init(self):
"Testing Envelope initilization."
e1 = Envelope((0, 0, 5, 5))
e2 = Envelope(0, 0, 5, 5)
e3 = Envelope(0, '0', '5', 5) # Thanks to ww for this
e4 = Envelope(e1._envelope)
self.assertRaises(OGRException, Envelope, (5, 5, 0, 0))
self.assertRaises(OGRException, Envelope, 5, 5, 0, 0)
self.assertRaises(OGRException, Envelope, (0, 0, 5, 5, 3))
self.assertRaises(OGRException, Envelope, ())
self.assertRaises(ValueError, Envelope, 0, 'a', 5, 5)
self.assertRaises(TypeError, Envelope, u'foo')
def calc_cache(self, save=True):
# GeoJSON
geojson = json.loads(serialize(
'geojson',
self.geoarea_set.all(),
geometry_field='polygons',
fields=('pk', 'title', 'code', 'parent'),
))
# Titles
titles = {}
for geo_area in self.geoarea_set.all():
titles[str(geo_area.id)] = {
'title': geo_area.title,
'parent_id': str(geo_area.parent.pk) if geo_area.parent else None,
'code': geo_area.code,
}
self.geo_area_titles = titles
# Bounds
bounds = {}
areas = self.geoarea_set.filter(polygons__isnull=False)
if areas.count() > 0:
try:
envelope = Envelope(*areas[0].polygons.extent)
for area in areas[1:]:
envelope.expand_to_include(*area.polygons.extent)
bounds = {
'minX': envelope.min_x,
'minY': envelope.min_y,
'maxX': envelope.max_x,
'maxY': envelope.max_y,
}
except ValueError:
pass
self.geojson_file.save(
f'admin-level-{self.pk}.json',
ContentFile(
json.dumps(geojson, cls=DjangoJSONEncoder).encode('utf-8'),
),
)
self.bounds_file.save(
f'admin-level-{self.pk}.json',
ContentFile(
json.dumps({'bounds': bounds}, cls=DjangoJSONEncoder).encode('utf-8'),
),
)
if save:
self.save()
def index_layer(index, obj):
start = end = None
try:
start, end = obj.get_time_extent()
except:
_logger.warn('could not get time info for %s', obj.typename)
if start:
index.time_start = util.iso_str_to_jdate(start)
if end:
index.time_end = util.iso_str_to_jdate(end)
try:
wms_metadata = obj.metadata()
except:
_logger.warn('could not get WMS info for %s', obj.typename)
return
min_x, min_y, max_x, max_y = wms_metadata.boundingBoxWGS84
if wms_metadata.boundingBoxWGS84 != (0.0, 0.0, -1.0, -1.0):
try:
index.extent = Envelope(min_x, min_y, max_x, max_y).wkt
except Exception, ex:
_logger.warn('Error computing envelope: %s, bounding box was %s',
str(ex), wms_metadata.boundingBoxWGS84)
def get_wms_mapnik_response(query_string, mapnik_file, name, base_url, geom):
data = QueryDict(query_string)
if data.get('request') == 'GetCapabilities' or data.get(
'REQUEST') == 'GetCapabilities':
templ = string.Template(wms_template)
prms = {}
prms['name'] = name
prms['title'] = name
prms['url'] = base_url
env = geom.ogr.envelope
prms['minx'] = str(env.min_x)
prms['miny'] = str(env.min_y)
prms['maxx'] = str(env.max_x)
prms['maxy'] = str(env.max_y)
#return source.extent.wkt, 'text/xml', False
return templ.substitute(prms), 'text/xml', False
height = data.get('HEIGHT') or data.get('height')
width = data.get('WIDTH') or data.get('width')
srs = data.get('SRS') or data.get('srs')
bbox = data.get('BBOX') or data.get('bbox')
transparent = data.get('TRANSPARENT', False) or data.get('transparent')
#request = 'GetMap'
#service = 'WMS'
#version = '1.1.1'
#format = 'image/jpeg' 'image/png'
if not data or not height or not width or not srs or not bbox:
raise Exception(
'Не найден один из обязательных атрибутов: data, height, width, srs, bbox'
)
width = int(width)
height = int(height)
srs = SpatialReference(srs)
m = mapnik.Map(width, height)
mapnik.load_map(
m, mapnik_file.encode('utf8')) # TODO: проверить работу с кириллицей
if transparent:
m.background = mapnik.Color('transparent'.encode('utf8'))
else:
m.background = mapnik.Color('white'.encode('utf8'))
prj1 = mapnik.Projection(str(srs.proj4))
m.srs = prj1.params()
bbox = [float(coord) for coord in bbox.split(',')]
bbox = Envelope(bbox)
bbox_polygon = OGRGeometry(bbox.wkt, srs=srs)
map_bbox = mapnik.Box2d(*bbox_polygon.envelope.tuple)
m.zoom_to_box(map_bbox)
im = mapnik.Image(width, height)
mapnik.render(m, im)
content = im.tostring('png256'.encode('utf8'))
content_type = 'image/png'
error = False
return content, content_type, error
def extent(self, srid=WEB_MERCATOR_SRID):
"""
Returns bbox for layer.
"""
if not self._bbox or self._bbox_srid != srid:
# Get bbox for raster in original coordinates
meta = self.metadata
xmin = meta.uperleftx
ymax = meta.uperlefty
xmax = xmin + meta.width * meta.scalex
ymin = ymax + meta.height * meta.scaley
# Create Polygon box
geom = OGRGeometry(Envelope((xmin, ymin, xmax, ymax)).wkt)
# Set original srs
if meta.srs_wkt:
geom.srs = SpatialReference(meta.srs_wkt)
else:
geom.srid = meta.srid
# Transform to requested srid
geom.transform(srid)
# Calculate value range for bbox
coords = geom.coords[0]
xvals = [x[0] for x in coords]
yvals = [x[1] for x in coords]
# Set bbox
self._bbox = (min(xvals), min(yvals), max(xvals), max(yvals))
self._bbox_srid = srid
return self._bbox
def test01_init(self):
"Testing Envelope initilization."
e1 = Envelope((0, 0, 5, 5))
Envelope(0, 0, 5, 5)
Envelope(0, '0', '5', 5) # Thanks to ww for this
Envelope(e1._envelope)
self.assertRaises(OGRException, Envelope, (5, 5, 0, 0))
self.assertRaises(OGRException, Envelope, 5, 5, 0, 0)
self.assertRaises(OGRException, Envelope, (0, 0, 5, 5, 3))
self.assertRaises(OGRException, Envelope, ())
self.assertRaises(ValueError, Envelope, 0, 'a', 5, 5)
self.assertRaises(TypeError, Envelope, 'foo')
self.assertRaises(OGRException, Envelope, (1, 1, 0, 0))
try:
Envelope(0, 0, 0, 0)
except OGRException:
self.fail("shouldn't raise an exception for min_x == max_x or min_y == max_y")
def filter_by_extent(model, q, extent, user=None):
env = Envelope(extent)
index = _index_for_model(model)
extent_ids = index.objects.filter(extent__contained=env.wkt)
if user:
extent_ids = extent_ids.values('indexed__owner')
return q.filter(user__in=extent_ids)
else:
extent_ids = extent_ids.values('indexed')
return q.filter(id__in=extent_ids)
def test02_properties(self):
"Testing Envelope properties."
e = Envelope(0, 0, 2, 3)
self.assertEqual(0, e.min_x)
self.assertEqual(0, e.min_y)
self.assertEqual(2, e.max_x)
self.assertEqual(3, e.max_y)
self.assertEqual((0, 0), e.ll)
self.assertEqual((2, 3), e.ur)
self.assertEqual((0, 0, 2, 3), e.tuple)
self.assertEqual('POLYGON((0.0 0.0,0.0 3.0,2.0 3.0,2.0 0.0,0.0 0.0))', e.wkt)
self.assertEqual('(0.0, 0.0, 2.0, 3.0)', str(e))
def read_node(f, filter_env, ids):
"""
Follows query_node() in plugins/input/shape/shp_index.hpp
"""
(offset,) = struct.unpack('i', f.read(4))
envelope = OGRGeometry(Envelope(*struct.unpack('4d', f.read(32))).wkt)
(shape_count,) = struct.unpack('i', f.read(4))
if not envelope.intersects(filter_env):
f.seek(offset + shape_count * 4 + 4, 1)
return
ids.extend(struct.unpack('%di' % shape_count, f.read(4 * shape_count)))
(num_children,) = struct.unpack('i', f.read(4))
for i in xrange(num_children):
read_node(f, filter_env, ids)
def read_shapeindex(f, extent):
"""
Reads the binary index as written out by quadtree.hpp in
mapnik/utils/shapeindex
"""
# Read the header -- 16 bytes -- just a sanity check
(name, zeropad) = struct.unpack('6s10s', f.read(16))
assert name == 'mapnik' and zeropad == '\x00' * 10
ids = []
filter_env = OGRGeometry(Envelope(*extent).wkt)
read_node(f, filter_env, ids)
ids.sort()
return ids
def index_map(index, obj):
time_start = None
time_end = None
extent = Envelope(0, 0, 0, 0)
for l in obj.local_layers:
start = end = None
try:
start, end = l.get_time_extent()
except:
_logger.warn('could not get time info for %s', l.typename)
if start:
start = util.iso_str_to_jdate(start)
if time_start is None:
time_start = start
else:
time_start = min(time_start, start)
if end:
end = util.iso_str_to_jdate(end)
if time_end is None:
time_end = start
else:
time_end = max(time_end, end)
try:
wms_metadata = l.metadata()
extent.expand_to_include(wms_metadata.boundingBoxWGS84)
except:
_logger.warn('could not get WMS info for %s', l.typename)
if time_start:
index.time_start = time_start
if time_end:
index.time_end = time_end
index.extent = extent.wkt
index.save()
def index_map(index, obj):
time_start = None
time_end = None
extent = Envelope(0,0,0,0)
for l in obj.local_layers:
start = end = None
try:
start, end = l.get_time_extent()
except:
_logger.warn('could not get time info for %s', l.typename)
if start:
start = util.iso_str_to_jdate(start)
if time_start is None:
time_start = start
else:
time_start = min(time_start, start)
if end:
end = util.iso_str_to_jdate(end)
if time_end is None:
time_end = start
else:
time_end = max(time_end, end)
try:
wms_metadata = l.metadata()
extent.expand_to_include(wms_metadata.boundingBoxWGS84)
except:
_logger.warn('could not get WMS info for %s', l.typename )
if time_start:
index.time_start = time_start
if time_end:
index.time_end = time_end
index.extent = extent.wkt
index.save()
def setUp(self):
self.e = Envelope(0, 0, 5, 5)
def test07_expand_to_include_envelope(self):
"Testing Envelope expand_to_include with Envelope as parameter."
self.e.expand_to_include(Envelope(-1, 1, 3, 7))
self.assertEqual((-1, 0, 5, 7), self.e)
class EnvelopeTest(unittest.TestCase):
def setUp(self):
self.e = Envelope(0, 0, 5, 5)
def test01_init(self):
"Testing Envelope initialization."
e1 = Envelope((0, 0, 5, 5))
Envelope(0, 0, 5, 5)
Envelope(0, '0', '5', 5) # Thanks to ww for this
Envelope(e1._envelope)
self.assertRaises(GDALException, Envelope, (5, 5, 0, 0))
self.assertRaises(GDALException, Envelope, 5, 5, 0, 0)
self.assertRaises(GDALException, Envelope, (0, 0, 5, 5, 3))
self.assertRaises(GDALException, Envelope, ())
self.assertRaises(ValueError, Envelope, 0, 'a', 5, 5)
self.assertRaises(TypeError, Envelope, 'foo')
self.assertRaises(GDALException, Envelope, (1, 1, 0, 0))
try:
Envelope(0, 0, 0, 0)
except GDALException:
self.fail("shouldn't raise an exception for min_x == max_x or min_y == max_y")
def test02_properties(self):
"Testing Envelope properties."
e = Envelope(0, 0, 2, 3)
self.assertEqual(0, e.min_x)
self.assertEqual(0, e.min_y)
self.assertEqual(2, e.max_x)
self.assertEqual(3, e.max_y)
self.assertEqual((0, 0), e.ll)
self.assertEqual((2, 3), e.ur)
self.assertEqual((0, 0, 2, 3), e.tuple)
self.assertEqual('POLYGON((0.0 0.0,0.0 3.0,2.0 3.0,2.0 0.0,0.0 0.0))', e.wkt)
self.assertEqual('(0.0, 0.0, 2.0, 3.0)', str(e))
def test03_equivalence(self):
"Testing Envelope equivalence."
e1 = Envelope(0.523, 0.217, 253.23, 523.69)
e2 = Envelope((0.523, 0.217, 253.23, 523.69))
self.assertEqual(e1, e2)
self.assertEqual((0.523, 0.217, 253.23, 523.69), e1)
def test04_expand_to_include_pt_2_params(self):
"Testing Envelope expand_to_include -- point as two parameters."
self.e.expand_to_include(2, 6)
self.assertEqual((0, 0, 5, 6), self.e)
self.e.expand_to_include(-1, -1)
self.assertEqual((-1, -1, 5, 6), self.e)
def test05_expand_to_include_pt_2_tuple(self):
"Testing Envelope expand_to_include -- point as a single 2-tuple parameter."
self.e.expand_to_include((10, 10))
self.assertEqual((0, 0, 10, 10), self.e)
self.e.expand_to_include((-10, -10))
self.assertEqual((-10, -10, 10, 10), self.e)
def test06_expand_to_include_extent_4_params(self):
"Testing Envelope expand_to_include -- extent as 4 parameters."
self.e.expand_to_include(-1, 1, 3, 7)
self.assertEqual((-1, 0, 5, 7), self.e)
def test06_expand_to_include_extent_4_tuple(self):
"Testing Envelope expand_to_include -- extent as a single 4-tuple parameter."
self.e.expand_to_include((-1, 1, 3, 7))
self.assertEqual((-1, 0, 5, 7), self.e)
def test07_expand_to_include_envelope(self):
"Testing Envelope expand_to_include with Envelope as parameter."
self.e.expand_to_include(Envelope(-1, 1, 3, 7))
self.assertEqual((-1, 0, 5, 7), self.e)
def test08_expand_to_include_point(self):
"Testing Envelope expand_to_include with Point as parameter."
self.e.expand_to_include(TestPoint(-1, 1))
self.assertEqual((-1, 0, 5, 5), self.e)
self.e.expand_to_include(TestPoint(10, 10))
self.assertEqual((-1, 0, 10, 10), self.e)
def test03_equivalence(self):
"Testing Envelope equivalence."
e1 = Envelope(0.523, 0.217, 253.23, 523.69)
e2 = Envelope((0.523, 0.217, 253.23, 523.69))
self.assertEqual(e1, e2)
self.assertEqual((0.523, 0.217, 253.23, 523.69), e1)
except:
_logger.warn('could not get WMS info for %s', obj.typename)
return
min_x, min_y, max_x, max_y = wms_metadata.boundingBoxWGS84
if wms_metadata.boundingBoxWGS84 != (0.0, 0.0, -1.0, -1.0):
try:
index.extent = Envelope(min_x, min_y, max_x, max_y).wkt
except Exception, ex:
_logger.warn('Error computing envelope: %s, bounding box was %s',
str(ex), wms_metadata.boundingBoxWGS84)
else:
#@todo might be better to have a nullable extent
_logger.warn('Bounding box empty, adding default envelope')
index.extent = Envelope(-180, -90, 180, 90).wkt
index.save()
def index_map(index, obj):
time_start = None
time_end = None
extent = Envelope(0, 0, 0, 0)
for l in obj.local_layers:
start = end = None
try:
start, end = l.get_time_extent()
except:
_logger.warn('could not get time info for %s', l.typename)
def test01_init(self):
"Testing Envelope initialization."
e1 = Envelope((0, 0, 5, 5))
Envelope(0, 0, 5, 5)
Envelope(0, '0', '5', 5) # Thanks to ww for this
Envelope(e1._envelope)
with self.assertRaises(GDALException):
Envelope((5, 5, 0, 0))
with self.assertRaises(GDALException):
Envelope(5, 5, 0, 0)
with self.assertRaises(GDALException):
Envelope((0, 0, 5, 5, 3))
with self.assertRaises(GDALException):
Envelope(())
with self.assertRaises(ValueError):
Envelope(0, 'a', 5, 5)
with self.assertRaises(TypeError):
Envelope('foo')
with self.assertRaises(GDALException):
Envelope((1, 1, 0, 0))
# Shouldn't raise an exception for min_x == max_x or min_y == max_y
Envelope(0, 0, 0, 0)
def setUp(self):
self.e = Envelope(0, 0, 5, 5)
class EnvelopeTest(unittest.TestCase):
def setUp(self):
self.e = Envelope(0, 0, 5, 5)
def test01_init(self):
"Testing Envelope initilization."
e1 = Envelope((0, 0, 5, 5))
Envelope(0, 0, 5, 5)
Envelope(0, '0', '5', 5) # Thanks to ww for this
Envelope(e1._envelope)
self.assertRaises(OGRException, Envelope, (5, 5, 0, 0))
self.assertRaises(OGRException, Envelope, 5, 5, 0, 0)
self.assertRaises(OGRException, Envelope, (0, 0, 5, 5, 3))
self.assertRaises(OGRException, Envelope, ())
self.assertRaises(ValueError, Envelope, 0, 'a', 5, 5)
self.assertRaises(TypeError, Envelope, 'foo')
self.assertRaises(OGRException, Envelope, (1, 1, 0, 0))
try:
Envelope(0, 0, 0, 0)
except OGRException:
self.fail("shouldn't raise an exception for min_x == max_x or min_y == max_y")
def test02_properties(self):
"Testing Envelope properties."
e = Envelope(0, 0, 2, 3)
self.assertEqual(0, e.min_x)
self.assertEqual(0, e.min_y)
self.assertEqual(2, e.max_x)
self.assertEqual(3, e.max_y)
self.assertEqual((0, 0), e.ll)
self.assertEqual((2, 3), e.ur)
self.assertEqual((0, 0, 2, 3), e.tuple)
self.assertEqual('POLYGON((0.0 0.0,0.0 3.0,2.0 3.0,2.0 0.0,0.0 0.0))', e.wkt)
self.assertEqual('(0.0, 0.0, 2.0, 3.0)', str(e))
def test03_equivalence(self):
"Testing Envelope equivalence."
e1 = Envelope(0.523, 0.217, 253.23, 523.69)
e2 = Envelope((0.523, 0.217, 253.23, 523.69))
self.assertEqual(e1, e2)
self.assertEqual((0.523, 0.217, 253.23, 523.69), e1)
def test04_expand_to_include_pt_2_params(self):
"Testing Envelope expand_to_include -- point as two parameters."
self.e.expand_to_include(2, 6)
self.assertEqual((0, 0, 5, 6), self.e)
self.e.expand_to_include(-1, -1)
self.assertEqual((-1, -1, 5, 6), self.e)
def test05_expand_to_include_pt_2_tuple(self):
"Testing Envelope expand_to_include -- point as a single 2-tuple parameter."
self.e.expand_to_include((10, 10))
self.assertEqual((0, 0, 10, 10), self.e)
self.e.expand_to_include((-10, -10))
self.assertEqual((-10, -10, 10, 10), self.e)
def test06_expand_to_include_extent_4_params(self):
"Testing Envelope expand_to_include -- extent as 4 parameters."
self.e.expand_to_include(-1, 1, 3, 7)
self.assertEqual((-1, 0, 5, 7), self.e)
def test06_expand_to_include_extent_4_tuple(self):
"Testing Envelope expand_to_include -- extent as a single 4-tuple parameter."
self.e.expand_to_include((-1, 1, 3, 7))
self.assertEqual((-1, 0, 5, 7), self.e)
def test07_expand_to_include_envelope(self):
"Testing Envelope expand_to_include with Envelope as parameter."
self.e.expand_to_include(Envelope(-1, 1, 3, 7))
self.assertEqual((-1, 0, 5, 7), self.e)
def test08_expand_to_include_point(self):
"Testing Envelope expand_to_include with Point as parameter."
self.e.expand_to_include(TestPoint(-1, 1))
self.assertEqual((-1, 0, 5, 5), self.e)
self.e.expand_to_include(TestPoint(10, 10))
self.assertEqual((-1, 0, 10, 10), self.e)
