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 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 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 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 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 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)
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)
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)
