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