def add_geom_wkb(wkb):
f = self.makeOne(1)
self.failUnlessEqual(len(f.geometries()), 0)
f.add_geometries_from_wkb(unhexlify(wkb))
self.failUnlessEqual(len(f.geometries()), 1)
e = mapnik.Box2d()
self.failUnlessEqual(e.valid(), False)
for g in f.geometries():
if not e.valid():
e = g.envelope()
else:
e += g.envelope()
self.failUnlessEqual(e, f.envelope())
def test_add_geom_wkb():
# POLYGON ((30 10, 10 20, 20 40, 40 40, 30 10))
wkb = '010300000001000000050000000000000000003e4000000000000024400000000000002440000000000000344000000000000034400000000000004440000000000000444000000000000044400000000000003e400000000000002440'
geometry = mapnik.Geometry.from_wkb(unhexlify(wkb))
if hasattr(geometry, 'is_valid'):
# Those are only available when python-mapnik has been built with
# boost >= 1.56.
eq_(geometry.is_valid(), True)
eq_(geometry.is_simple(), True)
eq_(geometry.envelope(), mapnik.Box2d(10.0, 10.0, 40.0, 40.0))
geometry.correct()
if hasattr(geometry, 'is_valid'):
# valid after calling correct
eq_(geometry.is_valid(), True)
def createGrid01(envelopeParam,widthCount=1,heightCont=1):
"""
widthCount:列数 heightCont：行数
把输入的mapnik.Box2d按指定的行列数目进行划分，最后返回划分的格网
返回值是字典{（行号，列号）：box}
行列号从1开始
"""
reslut={}
width=abs(envelopeParam.minx-envelopeParam.maxx)/(widthCount*1.0)
height=abs(envelopeParam.maxy-envelopeParam.miny)/(heightCont*1.0)
for i in range(0,widthCount):
for j in range(0,heightCont):
box=mapnik.Box2d(envelopeParam.minx+i*width,envelopeParam.miny+j*height,envelopeParam.minx+(i+1)*width,envelopeParam.miny+(j+1)*height)
reslut[(i,j)]=box
return reslut
def __init__(self, centre_x=-20, centre_y=0, step=10):
super(CirclesDatasource, self).__init__(
geometry_type = mapnik.DataGeometryType.Polygon,
envelope = mapnik.Box2d(-180, -90, 180, 90),
data_type = mapnik.DataType.Vector
)
# note that the plugin loader will set all arguments to strings and will not try to parse them
centre_x = int(centre_x)
centre_y = int(centre_y)
step = int(step)
self.centre_x = centre_x
self.centre_y = centre_y
self.step = step
def render(self, zoom, x, y, fmt):
p0 = self.gproj.tile_nw(zoom, x, y + 1)
p1 = self.gproj.tile_nw(zoom, x + 1, y)
c0 = self.mproj.forward(mapnik.Coord(p0[0], p0[1]))
c1 = self.mproj.forward(mapnik.Coord(p1[0], p1[1]))
bbox = mapnik.Box2d(c0.x, c0.y, c1.x, c1.y)
im = mapnik.Image(*self.tile_size)
m = self.get_map()
m.zoom_to_box(bbox)
mapnik.render(m, im)
return im.tostring('png256')
def createGrid(envelopeParam,zoom):
"""
根据输入的Box2d范围 和瓦片等级zoom
生成在该范围的上对应等级的格网1~zoom(不包含zoom 级)
（废弃，该方法设计的格网与分辨率有关，不符合设计）
"""
resolution=getResoluton(zoom)
width=256*resolution
height=256*resolution
widthCount=int((envelopeParam.maxx-envelopeParam.minx)/width+1)
heightCont=int((envelopeParam.maxy-envelopeParam.miny)/height+1)
reslut={}
for i in range(0,widthCount):
for j in range(0,heightCont):
reslut[(i,j)]=mapnik.Box2d(envelopeParam.minx+i*width,envelopeParam.miny+j*height,envelopeParam.minx+(i+1)*width,envelopeParam.miny+(j+1)*height)
return reslut
def tile(self, x, y, z):
nw = self.deg(x, y, z)
se = self.deg(x + 1, y + 1, z)
xmin = nw[0]
ymin = se[1]
xmax = se[0]
ymax = nw[1]
m = mapnik.Map(256, 256)
m.srs = "+proj=merc +lon_0=0 +k=1 +x_0=0 +y_0=0 +a=6378137 +b=6378137 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs"
m.append_style("pointstyle", self.style)
layer = mapnik.Layer("pointlayer")
layer.datasource = self.datasource
layer.styles.append("pointstyle")
m.layers.append(layer)
bbox = mapnik.Box2d(xmin, ymin, xmax, ymax)
merc = mapnik.Projection(m.srs)
longlat = mapnik.Projection(
"+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs")
transform = mapnik.ProjTransform(longlat, merc)
merc_bbox = transform.forward(bbox)
m.zoom_to_box(merc_bbox)
m.buffer_size = 10
im = mapnik.Image(256, 256)
mapnik.render(m, im)
ims = im.tostring()
pim = PIL.Image.frombuffer("RGBA", (256, 256), ims, "raw", "RGBA", 0,
1)
buf = BytesIO()
pim.save(buf, "png")
self.db.tiles.remove({"id": self.id, "xyz": "%s_%s_%s" % (x, y, z)})
if buf.__sizeof__() == self.blanksize:
self.db.tiles.insert_one({
"id": self.id,
"xyz": "%s_%s_%s" % (x, y, z),
"blank": True
})
else:
self.db.tiles.insert_one({
"id": self.id,
"xyz": "%s_%s_%s" % (x, y, z),
"tile": Binary(buf.getvalue())
})
def render_tile(self, z, scale, p0, p1, metawidth, metaheight, debug):
# Calculate pixel positions of bottom-left & top-right
# Convert to LatLong (EPSG:4326)
l0 = self.tileproj.fromPixelToLL(p0, z)
l1 = self.tileproj.fromPixelToLL(p1, z)
# Convert to map projection (e.g. mercator co-ords EPSG:900913)
c0 = self.prj.forward(mapnik.Coord(l0[0], l0[1]))
c1 = self.prj.forward(mapnik.Coord(l1[0], l1[1]))
# Bounding box for the tile
bbox = mapnik.Box2d(c0.x, c0.y, c1.x, c1.y)
self.m.resize(metawidth * TILE_SIZE, metaheight * TILE_SIZE)
self.m.zoom_to_box(bbox)
self.m.buffer_size = BUF_SIZE
if debug >= 2:
self.lock.acquire()
print z, bbox, metawidth, metaheight
self.lock.release()
# Render image with default Agg renderer
metaimage = mapnik.Image(metawidth * TILE_SIZE, metaheight * TILE_SIZE)
mapnik.render(self.m, metaimage, scale)
# save metatile for debug purposes only
# metaimage.save("/media/henry/Tools/map/tiles/MyCycleMapHD/" + "%s"%z + "-" + "%s" % (p0[0]/TILE_SIZE) + "-" + "%s" % (p1[1]/TILE_SIZE)+".png", 'png256')
for my in range(0, metaheight):
for mx in range(0, metawidth):
tile = metaimage.view(mx * TILE_SIZE, my * TILE_SIZE,
TILE_SIZE, TILE_SIZE)
if debug >= 3:
self.lock.acquire()
print "Tile: x=", p0[0] / TILE_SIZE + mx, "y=", p1[
1] / TILE_SIZE + my, "z=", z
self.lock.release()
item = (Command.write, p0[0] / TILE_SIZE + mx,
p1[1] / TILE_SIZE + my, z, tile.tostring('png256'))
self.writer.put(item)
# commit batch if required (SQLite-db)
item = (Command.commit, None, None, None, None)
self.writer.put(item)
def parse_envelope(params):
"""Parse the map and return the bounding box."""
raw_extremas = params["bbox"].split(",")
if len(raw_extremas) != 4:
abort(400, "bounding box need four extremas")
try:
minx, miny, maxx, maxy = [float(extrema) for extrema in raw_extremas]
except ValueError:
abort(
400,
"Excepted the bounding box to be a comma separated "
"list of floating point numbers",
)
if (minx == maxx) or (miny == maxy):
abort(400, "envelope area shouldn't be 0")
bbox = mapnik.Box2d(minx, miny, maxx, maxy)
return bbox
def test_feature_hit_count():
raise Todo("need to optimize multigeom bbox handling in shapeindex")
# results in different results between shp and ogr!
#bbox = (-14284551.8434, 2074195.1992, -7474929.8687, 8140237.7628)
bbox = (1113194.91, 4512803.085, 2226389.82, 6739192.905)
query = mapnik.Query(mapnik.Box2d(*bbox))
if 'ogr' in mapnik.DatasourceCache.instance().plugin_names():
ds1 = mapnik.Ogr(file='../data/shp/world_merc.shp', layer_by_index=0)
for fld in ds1.fields():
query.add_property_name(fld)
ds2 = mapnik.Shapefile(file='../data/shp/world_merc.shp')
count1 = len(ds1.features(query).features)
count2 = len(ds2.features(query).features)
eq_(
count1, count2,
"Feature count differs between OGR driver (%s features) and Shapefile Driver (%s features) when querying the same bbox"
% (count1, count2))
def test_python_extended_constructor():
context = mapnik.Context()
context.push('foo')
context.push('foo')
f = mapnik.Feature(context, 1)
wkt = 'POLYGON ((35 10, 10 20, 15 40, 45 45, 35 10),(20 30, 35 35, 30 20, 20 30))'
f.geometry = mapnik.Geometry.from_wkt(wkt)
f['foo'] = 'bar'
eq_(f['foo'], 'bar')
eq_(f.envelope(), mapnik.Box2d(10.0, 10.0, 45.0, 45.0))
# reset
f['foo'] = u"avión"
eq_(f['foo'], u"avión")
f['foo'] = 1.4
eq_(f['foo'], 1.4)
f['foo'] = True
eq_(f['foo'], True)
def render_bitmap(map_theme, tile_size):
assert tile_size <= 32768
map = mapnik.Map(tile_size, tile_size)
mapnik.load_map(map, map_theme)
# Zoom to EPSG:3857 bounding box
bbox = mapnik.Box2d(-20037508.34, -20037508.34, 20037508.34, 20037508.34)
map.zoom_to_box(bbox)
image = mapnik.Image(tile_size, tile_size)
mapnik.render(map, image)
raw_data = image.tostring()
pil_image = Image.frombuffer('RGBA', (tile_size, tile_size), raw_data,
'raw', 'RGBA', 0, 1)
del raw_data
pil_image = pil_image.convert(mode='L')
return np.array(pil_image)
def test_layer_init():
l = mapnik.Layer('test')
eq_(l.name, 'test')
eq_(l.srs, '+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs')
eq_(l.envelope(), mapnik.Box2d())
eq_(l.clear_label_cache, False)
eq_(l.cache_features, False)
eq_(l.visible(1), True)
eq_(l.active, True)
eq_(l.datasource, None)
eq_(l.queryable, False)
eq_(l.minimum_scale_denominator, 0.0)
eq_(l.maximum_scale_denominator > 1e+6, True)
eq_(l.group_by, "")
eq_(l.maximum_extent, None)
eq_(l.buffer_size, None)
eq_(len(l.styles), 0)
def test_visual_zoom_all_rendering1():
m = mapnik.Map(512, 512)
mapnik.load_map(m, '../data/good_maps/wgs842merc_reprojection.xml')
merc_bounds = mapnik.Box2d(-20037508.34, -20037508.34, 20037508.34,
20037508.34)
m.maximum_extent = merc_bounds
m.zoom_all()
im = mapnik.Image(512, 512)
mapnik.render(m, im)
actual = '/tmp/mapnik-wgs842merc-reprojection-render.png'
expected = 'images/support/mapnik-wgs842merc-reprojection-render.png'
im.save(actual)
expected_im = mapnik.Image.open(expected)
eq_(
im.tostring(), expected_im.tostring(),
'failed comparing actual (%s) and expected (%s)' %
(actual, 'tests/python_tests/' + expected))
def test_map_query_in_pixels_works2():
m = mapnik.Map(256, 256)
mapnik.load_map(m, '../data/good_maps/merc2wgs84_reprojection.xml')
wgs84_bounds = mapnik.Box2d(-179.999999975, -85.0511287776,
179.999999975, 85.0511287776)
m.maximum_extent = wgs84_bounds
# caution - will go square due to evil aspect_fix_mode backhandedness
m.zoom_all()
# validate that aspect_fix_mode modified the bbox reasonably
e = m.envelope()
assert_almost_equal(e.minx, -179.999999975, places=7)
assert_almost_equal(e.miny, -167.951396161, places=7)
assert_almost_equal(e.maxx, 179.999999975, places=7)
assert_almost_equal(e.maxy, 192.048603789, places=7)
fs = m.query_map_point(0, 55, 100) # somewhere in Canada
feat = fs.next()
eq_(feat.attributes['NAME'], u'Canada')
def test_add_geom_wkb():
# POLYGON ((30 10, 10 20, 20 40, 40 40, 30 10))
wkb = '010300000001000000050000000000000000003e4000000000000024400000000000002440000000000000344000000000000034400000000000004440000000000000444000000000000044400000000000003e400000000000002440'
context = mapnik.Context()
f = mapnik.Feature(context, 1)
eq_(len(f.geometries()), 0)
f.add_geometries_from_wkb(unhexlify(wkb))
eq_(len(f.geometries()), 1)
e = mapnik.Box2d()
eq_(e.valid(), False)
for g in f.geometries():
if not e.valid():
e = g.envelope()
else:
e += g.envelope()
eq_(e, f.envelope())
def _renderMapnik(self,mapfile,c0,c1):
render_sizeX = int(self.tile_countX * self.tile_size)
render_sizeY = int(self.tile_countY * self.tile_size)
bbox = mapnik.Box2d(c0.x,c0.y, c1.x,c1.y)
#m = self.mp
m = mapnik.Map(int(render_sizeX), int(render_sizeX))
mapnik.load_map(m, mapfile, True)
m.resize(render_sizeX, render_sizeY)
m.zoom_to_box(bbox)
m.buffer_size = self.buffer_size
im = mapnik.Image(render_sizeX, render_sizeY)
mapnik.render(m, im)
im = Image.fromstring('RGBA',(render_sizeX, render_sizeY),im.tostring())
del m
m = None
return im
def test_passing_pycairo_context_pdf():
m = make_tmp_map()
m.zoom_to_box(mapnik.Box2d(-180,-90,180,90))
test_cairo_file = '/tmp/mapnik-cairo-context-test.pdf'
surface = cairo.PDFSurface(test_cairo_file, m.width, m.height)
expected_cairo_file = './images/pycairo/cairo-cairo-expected.pdf'
context = cairo.Context(surface)
mapnik.render(m,context)
draw_title(m,context,"Hello Map",size=20)
draw_neatline(m,context)
surface.finish()
if not os.path.exists(expected_cairo_file):
print 'generated expected cairo surface file %s' % expected_cairo_file
shutil.copy(test_cairo_file,expected_cairo_file)
diff = abs(os.stat(expected_cairo_file).st_size-os.stat(test_cairo_file).st_size)
msg = 'diff in size (%s) between actual (%s) and expected(%s)' % (diff,test_cairo_file,'tests/python_tests/'+ expected_cairo_file)
eq_( diff < 1500, True, msg)
os.remove(test_cairo_file)
def _prepare_rendering(self, bbox, width=None, height=None):
if not self._mapnik:
self._mapnik = mapnik.Map(width, height)
# Load style XML
mapnik.load_map(self._mapnik, self.stylefile, True)
# Obtain <Map> projection
self._prj = mapnik.Projection(self._mapnik.srs)
# Convert to map projection
assert len(bbox) == 4, _("Provide a bounding box tuple (minx, miny, maxx, maxy)")
c0 = self._prj.forward(mapnik.Coord(bbox[0], bbox[1]))
c1 = self._prj.forward(mapnik.Coord(bbox[2], bbox[3]))
# Bounding box for the tile
bbox = mapnik.Box2d(c0.x, c0.y, c1.x, c1.y)
self._mapnik.resize(width, height)
self._mapnik.zoom_to_box(bbox)
self._mapnik.buffer_size = 128
def run(self):
for t in self.__tiles:
bounds = t.bounds()
extent = mapnik.Box2d(bounds.xmin, bounds.ymin, bounds.xmax,
bounds.ymax)
self.__map.zoom_to_box(extent)
image = mapnik.Image(self.__map.width, self.__map.height)
mapnik.render(self.__map, image)
imagebuff = image.tostring(self.__md["format"])
if self.__compressing:
imagebuff = tiny(imagebuff, self.__map.width,
self.__map.height)
self.__queue.put(TileWorkerData(t, imagebuff))
def get_bbox(self, x, y, z):
# Calculate pixel positions of bottom-left & top-right
p0 = (x * self.render_size, (y + 1) * self.render_size)
p1 = ((x + 1) * self.render_size, y * self.render_size)
# Convert to LatLong (EPSG:4326)
l0 = self.tileproj.fromPixelToLL(p0, z)
l1 = self.tileproj.fromPixelToLL(p1, z)
# Convert to map projection (e.g. mercator co-ords EPSG:900913)
c0 = self.prj.forward(mapnik.Coord(l0[0], l0[1]))
c1 = self.prj.forward(mapnik.Coord(l1[0], l1[1]))
# Bounding box for the tile
if hasattr(mapnik,
'mapnik_version') and mapnik.mapnik_version() >= 800:
return mapnik.Box2d(c0.x, c0.y, c1.x, c1.y)
else:
return mapnik.Envelope(c0.x, c0.y, c1.x, c1.y)
def renderandSave(m, output, metadata, zoom=19, size=224):
" Faster than getTile"
# Define size of tile
if type(size) == tuple:
width = size[0]
height = size[1]
else:
width, height = size, size
# target projection
projection = '+proj=aeqd +ellps=WGS84 +lat_0={} +lon_0={}'.format(
90, -metadata['yaw'] + metadata['lon'])
merc = mapnik.Projection(projection)
# WGS lat/long source projection of centrel
longlat = mapnik.Projection(
'+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs')
# ensure the target map projection is mercator
m.srs = merc.params()
# transform the centre point into the target coord sys
centre = mapnik.Coord(metadata['lon'], metadata['lat'])
transform = mapnik.ProjTransform(longlat, merc)
merc_centre = transform.forward(centre)
# 360/(2**zoom) degrees = 256 px
# so in merc 1px = (20037508.34*2) / (256 * 2**zoom)
# hence to find the bounds of our rectangle in projected coordinates + and - half the image width worth of projected coord units
dx = ((20037508.34 * 2 * (width / 2))) / (width * (2**(zoom)))
minx = merc_centre.x - dx
maxx = merc_centre.x + dx
# grow the height bbox, as we only accurately set the width bbox
m.aspect_fix_mode = mapnik.aspect_fix_mode.ADJUST_BBOX_HEIGHT
bounds = mapnik.Box2d(
minx, merc_centre.y - 10, maxx, merc_centre.y +
10) # the y bounds will be fixed by mapnik due to ADJUST_BBOX_HEIGHT
m.zoom_to_box(bounds)
# render the map image to a file
mapnik.render_to_file(m, output)
def get_bbox(self): # Calculate pixel positions of bottom-left & top-right p0 = (self.mtx0 * TILE_SIZE, (self.mty0 + self.metatile) * TILE_SIZE) p1 = ((self.mtx0 + self.metatile) * TILE_SIZE, self.mty0 * TILE_SIZE) # Convert to LatLong (EPSG:4326) l0 = self.tileproj.fromPixelToLL(p0, self.zoom); l1 = self.tileproj.fromPixelToLL(p1, self.zoom); # Convert to map projection (e.g. mercator co-ords EPSG:900913) c0 = self.prj.forward(mapnik.Coord(l0[0],l0[1])) c1 = self.prj.forward(mapnik.Coord(l1[0],l1[1])) # Bounding box for the tile if hasattr(mapnik,'mapnik_version') and mapnik.mapnik_version() >= 800: bbox = mapnik.Box2d(c0.x,c0.y, c1.x,c1.y) else: bbox = mapnik.Envelope(c0.x,c0.y, c1.x,c1.y) return bbox
def render_image(self, extent, img_size, settings):
# Выбираем объекты по экстенту
feature_query = self.layer.feature_query()
feature_query.intersects(box(*extent, srid=self.layer.srs_id))
feature_query.geom()
features = feature_query()
ds = mapnik.MemoryDatasource()
for (id, f) in enumerate(features):
if mapnik.mapnik_version() < 200100:
feature = mapnik.Feature(id)
else:
feature = mapnik.Feature(mapnik.Context(), id)
feature.add_geometries_from_wkb(f.geom.wkb)
ds.add_feature(feature)
style_content = str(self.style_content)
m = mapnik.Map(img_size[0], img_size[1])
mapnik.load_map_from_string(m, style_content)
m.zoom_to_box(mapnik.Box2d(*extent))
layer = mapnik.Layer('main')
layer.datasource = ds
root = ET.fromstring(style_content)
styles = [s.attrib.get('name') for s in root.iter('Style')]
for s in styles:
layer.styles.append(s)
m.layers.append(layer)
img = mapnik.Image(img_size[0], img_size[1])
mapnik.render(m, img)
data = img.tostring('png')
# Преобразуем изображение из PNG в объект PIL
buf = StringIO()
buf.write(data)
buf.seek(0)
img = Image.open(buf)
return img
def render_tile(m, z, x, y, scale, dir, type, lock=None, threadnum=None):
n = 2**z
n2 = n / 2
x2n = x - n2
y2n = (n - y - 1) - n2
tilesize = float(scale) / float(n)
bbox = [
tilesize * x2n, tilesize * y2n, tilesize * (x2n + 1),
tilesize * (y2n + 1)
]
pdir = dir + "/" + str(z) + "/" + str(x)
if lock:
lock.acquire()
print "Thread #%u: z=%u x=%u y=%u -> (%f,%f,%f,%f)" % (
threadnum, z, x, y, bbox[0], bbox[1], bbox[2], bbox[3])
if not os.path.exists(pdir):
os.makedirs(pdir)
lock.release()
else:
if not os.path.exists(pdir):
os.makedirs(pdir)
print "z=%u x=%u y=%u -> (%f,%f,%f,%f)" % (z, x, y, bbox[0], bbox[1],
bbox[2], bbox[3])
if mapnik.Box2d:
e = mapnik.Box2d(*bbox)
else:
e = mapnik.Envelope(*bbox)
# zoom map to bounding box
m.zoom_to_box(e)
file = dir + "/" + str(z) + "/" + str(x) + "/" + str(y) + "." + type
s = mapnik.Image(256, 256)
mapnik.render(m, s)
view = s.view(0, 0, 256, 256)
view.save(file, type)
def test_render_points():
if not mapnik.has_cairo(): return
# create and populate point datasource (WGS84 lat-lon coordinates)
places_ds = mapnik.PointDatasource()
places_ds.add_point(142.48,-38.38,'Name','Westernmost Point') # westernmost
places_ds.add_point(143.10,-38.60,'Name','Southernmost Point') # southernmost
# create layer/rule/style
s = mapnik.Style()
r = mapnik.Rule()
symb = mapnik.PointSymbolizer()
symb.allow_overlap = True
r.symbols.append(symb)
s.rules.append(r)
lyr = mapnik.Layer('Places','+proj=latlon +datum=WGS84')
lyr.datasource = places_ds
lyr.styles.append('places_labels')
# latlon bounding box corners
ul_lonlat = mapnik.Coord(142.30,-38.20)
lr_lonlat = mapnik.Coord(143.40,-38.80)
# render for different projections
projs = {
'latlon': '+proj=latlon +datum=WGS84',
'merc': '+proj=merc +datum=WGS84 +k=1.0 +units=m +over +no_defs',
'google': '+proj=merc +ellps=sphere +R=6378137 +a=6378137 +units=m',
'utm': '+proj=utm +zone=54 +datum=WGS84'
}
for projdescr in projs.iterkeys():
m = mapnik.Map(1000, 500, projs[projdescr])
m.append_style('places_labels',s)
m.layers.append(lyr)
p = mapnik.Projection(projs[projdescr])
m.zoom_to_box(p.forward(mapnik.Box2d(ul_lonlat,lr_lonlat)))
# Render to SVG so that it can be checked how many points are there with string comparison
svg_file = os.path.join(tempfile.gettempdir(),'%s.svg')
mapnik.render_to_file(m, svg_file)
num_points_present = len(places_ds.all_features())
svg = open(svg_file,'r').read()
num_points_rendered = svg.count('<image ')
eq_(num_points_present, num_points_rendered, "Not all points were rendered (%d instead of %d) at projection %s" % (num_points_rendered, num_points_present, projdescr))
def test_render_grid2():
""" test old against new"""
width,height = 256,256
m = create_grid_map(width,height)
ul_lonlat = mapnik.Coord(142.30,-38.20)
lr_lonlat = mapnik.Coord(143.40,-38.80)
m.zoom_to_box(mapnik.Box2d(ul_lonlat,lr_lonlat))
# new method
grid = mapnik.Grid(m.width,m.height,key='Name')
mapnik.render_layer(m,grid,layer=0,fields=['Name'])
utf1 = grid.encode('utf',resolution=4)
eq_(utf1,grid_correct_new)
# old method - to be removed
utf2 = mapnik.render_grid(m,0,key='Name',resolution=4,fields=['Name'])
eq_(utf2,grid_correct)
# for complex polygons these will not be true
eq_(len(utf2['grid']),len(utf1['grid']))
eq_(len(utf2['keys']),len(utf1['keys']))
eq_(len(utf2['data']),len(utf1['data']))
# check a full view is the same as a full image
grid_view = grid.view(0,0,width,height)
# for kicks check at full res too
utf3 = grid.encode('utf',resolution=1)
utf4 = grid_view.encode('utf',resolution=1)
eq_(utf3['grid'],utf4['grid'])
eq_(utf3['keys'],utf4['keys'])
eq_(utf3['data'],utf4['data'])
eq_(resolve(utf4,0,0),None)
# resolve some center points in the
# resampled view
utf5 = grid_view.encode('utf',resolution=4)
eq_(resolve(utf5,25,10),{"Name": "North West"})
eq_(resolve(utf5,25,46),{"Name": "North East"})
eq_(resolve(utf5,38,10),{"Name": "South West"})
eq_(resolve(utf5,38,46),{"Name": "South East"})
def _render_mapfile(self, mapfile, query):
start_time = time.time()
m = self.map_obj(mapfile)
m.resize(query.size[0], query.size[1])
m.srs = '+init=%s' % str(query.srs.srs_code.lower())
envelope = mapnik.Box2d(*query.bbox)
m.zoom_to_box(envelope)
data = None
try:
if self.layers:
i = 0
for layer in m.layers[:]:
if layer.name != 'Unkown' and layer.name not in self.layers:
del m.layers[i]
else:
i += 1
img = mapnik.Image(query.size[0], query.size[1])
if self.scale_factor:
mapnik.render(m, img, self.scale_factor)
else:
mapnik.render(m, img)
data = img.tostring(str(query.format))
finally:
size = None
if data:
size = len(data)
log_request('%s:%s:%s:%s' %
(mapfile, query.bbox, query.srs.srs_code, query.size),
status='200' if data else '500',
size=size,
method='API',
duration=time.time() - start_time)
return ImageSource(BytesIO(data),
size=query.size,
image_opts=ImageOptions(
transparent=self.transparent,
format=query.format))
def simpleRendering(image, stylesheet, extent):
mapfile = stylesheet
map_uri = image
imgx = 256
imgy = 256
m = mapnik.Map(imgx, imgy)
mapnik.load_map(m, mapfile)
#print 'simple Rendering'
#print m.layers
if hasattr(mapnik, 'mapnik_version') and mapnik.mapnik_version() >= 800:
bbox = mapnik.Box2d(extent[0], extent[2], extent[1], extent[3])
else:
bbox = mapnik.Envelope(extent[0], extent[2], extent[1], extent[3])
m.zoom_to_box(bbox)
im = mapnik.Image(imgx, imgy)
mapnik.render(m, im)
view = im.view(0, 0, imgx, imgy) # x,y,width,height
view.save(map_uri, 'png')
def render(self, **kwargs):
m = mapnik.Map(kwargs['width'], kwargs['height'], '+init=epsg:' + str(kwargs['epsg']))
s = mapnik.Style()
r = mapnik.Rule()
polygon_symbolizer = mapnik.PolygonSymbolizer(mapnik.Color(str(kwargs['color'])))
polygon_symbolizer.fill_opacity = kwargs['opacity']
r.symbols.append(polygon_symbolizer)
line_symbolizer = mapnik.LineSymbolizer(mapnik.Color('rgb(50%,50%,50%)'), 1.0)
r.symbols.append(line_symbolizer)
point_symbolizer = mapnik.PointSymbolizer()
r.symbols.append(point_symbolizer)
s.rules.append(r)
m.append_style('My Style', s)
ds = mapnik.Ogr(string=json.dumps(kwargs['geojson']), layer='OGRGeoJSON')
layer = mapnik.Layer('wkt', '+init=epsg:' + str(kwargs['epsg']))
layer.datasource = ds
layer.styles.append('My Style')
m.layers.append(layer)
extent = mapnik.Box2d(kwargs['bbox'][0], kwargs['bbox'][1], kwargs['bbox'][2], kwargs['bbox'][3])
m.zoom_to_box(extent)
mapnik.render_to_file(m, str(kwargs['filename']), str(kwargs['filetype']))
