import mapnik m = mapnik.Map(1280, 720) m.background = mapnik.Color('steelblue') s = mapnik.Style() r = mapnik.Rule() polygon_symbolizer = mapnik.PolygonSymbolizer() polygon_symbolizer.fill = mapnik.Color('green') r.symbols.append(polygon_symbolizer) s.rules.append(r) m.append_style('Bangkit', s) ds = mapnik.Shapefile(file="propinsi/INDONESIA_PROP.shp") layer = mapnik.Layer('indonesia') layer.datasource = ds layer.styles.append('Bangkit') m.layers.append(layer) #test s = mapnik.Style() r = mapnik.Rule() basinsLabels = mapnik.TextSymbolizer(mapnik.Expression('[nama]'), 'DejaVu Sans Bold', 3, mapnik.Color('red')) basinsLabels.halo_fill = mapnik.Color('yellow') basinsLabels.halo_radius = 1 r.symbols.append(basinsLabels) point_sym = mapnik.PointSymbolizer()
def map_render(map_id): m = mapnik.Map(1920, 1080) m.background = mapnik.Color('steelblue') dbname = settings.DATABASES['default']['NAME'] user = settings.DATABASES['default']['USER'] password = settings.DATABASES['default']['PASSWORD'] params = dict( dbname=dbname, table='(select * from test_task_2_testfields where field_id=' + str(map_id) + ') as query', user=user, password=password) postgis = mapnik.PostGIS(**params) lyr = mapnik.Layer('PostGis Layer') lyr.datasource = postgis ######## main style main_rule = mapnik.Rule() main_style = mapnik.Style() main_style.rules.append(main_rule) m.append_style('main', main_style) ######### red style for productivi <= 30 red_filter = mapnik.Filter("[productivi] <= 30") red_style = mapnik.Style() red_rule = mapnik.Rule() red_rule.filter = red_filter polygon_symbolizer = mapnik.PolygonSymbolizer() polygon_symbolizer.fill = mapnik.Color('#FF0000') red_rule.symbols.append(polygon_symbolizer) red_style.rules.append(red_rule) m.append_style('red', red_style) # orange style for productivi >= 31 and < 70 orange_filter = mapnik.Filter( "([productivi] > 30) and ([productivi] < 70)") orange_style = mapnik.Style() orange_rule = mapnik.Rule() orange_rule.filter = orange_filter polygon_symbolizer = mapnik.PolygonSymbolizer() polygon_symbolizer.fill = mapnik.Color('#FF8000') orange_rule.symbols.append(polygon_symbolizer) orange_style.rules.append(orange_rule) m.append_style('orange', orange_style) ######## green style for productivi >+ 70 green_filter = mapnik.Filter("([productivi] >= 70)") green_style = mapnik.Style() green_rule = mapnik.Rule() green_rule.filter = green_filter polygon_symbolizer = mapnik.PolygonSymbolizer() polygon_symbolizer.fill = mapnik.Color('#00FF00') green_rule.symbols.append(polygon_symbolizer) green_style.rules.append(green_rule) m.append_style('green', green_style) ######## render lyr.styles.append('main') lyr.styles.append('red') lyr.styles.append('orange') lyr.styles.append('green') m.layers.append(lyr) m.zoom_all() if not os.path.exists('media/Map'): os.makedirs('media/Map') mapnik.render_to_file(m, 'media/Map/map.png', 'png')
polygon_symbolizer = mapnik.PolygonSymbolizer() polygon_symbolizer.fill = mapnik.Color('#f2eff9') rule.symbols.append(polygon_symbolizer) # Create a LineSymbolizer to style the polygons borders and add it to the rule line_symbolizer = mapnik.LineSymbolizer() line_symbolizer.stroke = mapnik.Color('rgb(50%, 50%, 50%)') line_symbolizer.stroke_width = 0.1 rule.symbols.append(line_symbolizer) # Add the rule to the style style.rules.append(rule) # Add the style to the map map.append_style('My Style', style) # Create a data source from a shapefile data = mapnik.Shapefile(file='../../data/world_borders_simple.shp') # Create a layer giving it the name 'world' layer = mapnik.Layer('world') # Set the layer data source and add the style to the layer layer.datasource = data layer.styles.append('My Style') # Add the layer to the map map.layers.append(layer) # Zoom the map to the extent of all layers map.zoom_all() # Write the map to an image mapnik.render_to_file(map, '../output/world_python.png', 'png')
def _test_grayscale_subquery(lbl, pixtype, value): # # 3 8 13 # +---+---+---+ # 3 | v | v | v | NOTE: writes different color # +---+---+---+ in 13,8 and 8,13 # 8 | v | v | a | # +---+---+---+ # 13 | v | b | v | # +---+---+---+ # val_a = int(value / 3) val_b = val_a * 2 sql = "(select 3 as i, " \ " ST_SetValues(" \ " ST_SetValues(" \ " ST_AsRaster(" \ " ST_MakeEnvelope(0,0,14,14), " \ " 1.0, -1.0, '%s', %s" \ " ), " \ " 11, 6, 4, 5, %s::float8" \ " )," \ " 6, 11, 5, 4, %s::float8" \ " ) as \"R\"" \ ") as foo" % (pixtype, value, val_a, val_b) rescale = 0 clip = 0 if rescale: lbl += ' Sc' if clip: lbl += ' Cl' ds = mapnik.PgRaster(dbname=MAPNIK_TEST_DBNAME, table=sql, raster_field='"R"', use_overviews=1, prescale_rasters=rescale, clip_rasters=clip) fs = ds.featureset() feature = fs.next() eq_(feature['i'], 3) lyr = mapnik.Layer('grayscale_subquery') lyr.datasource = ds expenv = mapnik.Box2d(0, 0, 14, 14) env = lyr.envelope() assert_almost_equal(env.minx, expenv.minx, places=0) assert_almost_equal(env.miny, expenv.miny, places=0) assert_almost_equal(env.maxx, expenv.maxx, places=0) assert_almost_equal(env.maxy, expenv.maxy, places=0) mm = mapnik.Map(15, 15) style = mapnik.Style() sym = mapnik.RasterSymbolizer() rule = mapnik.Rule() rule.symbols.append(sym) style.rules.append(rule) mm.append_style('foo', style) lyr.styles.append('foo') mm.layers.append(lyr) mm.zoom_to_box(expenv) im = mapnik.Image(mm.width, mm.height) t0 = time.time() # we want wall time to include IO waits mapnik.render(mm, im) lap = time.time() - t0 log('T ' + str(lap) + ' -- ' + lbl + ' E:full') expected = 'images/support/pgraster/%s-%s-%s-%s.png' % (lyr.name, lbl, pixtype, value) compare_images(expected, im) h = format(value, '02x') hex_v = h + h + h + 'ff' hex_v = hex_v.encode() h = format(val_a, '02x') hex_a = h + h + h + 'ff' hex_a = hex_a.encode() h = format(val_b, '02x') hex_b = h + h + h + 'ff' hex_b = hex_b.encode() eq_(hexlify(im.view(3, 3, 1, 1).tostring()), hex_v) eq_(hexlify(im.view(8, 3, 1, 1).tostring()), hex_v) eq_(hexlify(im.view(13, 3, 1, 1).tostring()), hex_v) eq_(hexlify(im.view(3, 8, 1, 1).tostring()), hex_v) eq_(hexlify(im.view(8, 8, 1, 1).tostring()), hex_v) eq_(hexlify(im.view(13, 8, 1, 1).tostring()), hex_a) eq_(hexlify(im.view(3, 13, 1, 1).tostring()), hex_v) eq_(hexlify(im.view(8, 13, 1, 1).tostring()), hex_b) eq_(hexlify(im.view(13, 13, 1, 1).tostring()), hex_v)
def _test_rgba_subquery(lbl, pixtype, r, g, b, a, g1, b1): # # 3 8 13 # +---+---+---+ # 3 | v | v | h | NOTE: writes different alpha # +---+---+---+ in 13,8 and 8,13 # 8 | v | v | a | # +---+---+---+ # 13 | v | b | v | # +---+---+---+ # sql = "(select 3 as i, " \ " ST_SetValues(" \ " ST_SetValues(" \ " ST_AddBand(" \ " ST_AddBand(" \ " ST_AddBand(" \ " ST_AsRaster(" \ " ST_MakeEnvelope(0,0,14,14), " \ " 1.0, -1.0, '%s', %s" \ " )," \ " '%s', %d::float" \ " ), " \ " '%s', %d::float" \ " ), " \ " '%s', %d::float" \ " ), " \ " 2, 11, 6, 4, 5, %s::float8" \ " )," \ " 3, 6, 11, 5, 4, %s::float8" \ " ) as r" \ ") as foo" % ( pixtype, r, pixtype, g, pixtype, b, pixtype, a, g1, b1) overview = '' rescale = 0 clip = 0 if rescale: lbl += ' Sc' if clip: lbl += ' Cl' ds = mapnik.PgRaster(dbname=MAPNIK_TEST_DBNAME, table=sql, raster_field='r', use_overviews=0 if overview else 0, prescale_rasters=rescale, clip_rasters=clip) fs = ds.featureset() feature = fs.next() eq_(feature['i'], 3) lyr = mapnik.Layer('rgba_subquery') lyr.datasource = ds expenv = mapnik.Box2d(0, 0, 14, 14) env = lyr.envelope() assert_almost_equal(env.minx, expenv.minx, places=0) assert_almost_equal(env.miny, expenv.miny, places=0) assert_almost_equal(env.maxx, expenv.maxx, places=0) assert_almost_equal(env.maxy, expenv.maxy, places=0) mm = mapnik.Map(15, 15) style = mapnik.Style() sym = mapnik.RasterSymbolizer() rule = mapnik.Rule() rule.symbols.append(sym) style.rules.append(rule) mm.append_style('foo', style) lyr.styles.append('foo') mm.layers.append(lyr) mm.zoom_to_box(expenv) im = mapnik.Image(mm.width, mm.height) t0 = time.time() # we want wall time to include IO waits mapnik.render(mm, im) lap = time.time() - t0 log('T ' + str(lap) + ' -- ' + lbl + ' E:full') expected = 'images/support/pgraster/%s-%s-%s-%s-%s-%s-%s-%s-%s.png' % ( lyr.name, lbl, pixtype, r, g, b, a, g1, b1) compare_images(expected, im) hex_v = format(r << 24 | g << 16 | b << 8 | a, '08x').encode() hex_a = format(r << 24 | g1 << 16 | b << 8 | a, '08x').encode() hex_b = format(r << 24 | g << 16 | b1 << 8 | a, '08x').encode() eq_(hexlify(im.view(3, 3, 1, 1).tostring()), hex_v) eq_(hexlify(im.view(8, 3, 1, 1).tostring()), hex_v) eq_(hexlify(im.view(13, 3, 1, 1).tostring()), hex_v) eq_(hexlify(im.view(3, 8, 1, 1).tostring()), hex_v) eq_(hexlify(im.view(8, 8, 1, 1).tostring()), hex_v) eq_(hexlify(im.view(13, 8, 1, 1).tostring()), hex_a) eq_(hexlify(im.view(3, 13, 1, 1).tostring()), hex_v) eq_(hexlify(im.view(8, 13, 1, 1).tostring()), hex_b) eq_(hexlify(im.view(13, 13, 1, 1).tostring()), hex_v)
s = mapnik.Style() r = mapnik.Rule() point_sym = mapnik.PointSymbolizer() point_sym.filename = './symbols/airport.p.16.png' r.symbols.append(point_sym) # add the symbolizer to the rule object s.rules.append(r) # now add the rule to the style and we're done m.append_style('airport point', s) #add your data source.. usually would be a PostgreSQL/SQLite database ds = mapnik.MemoryDatasource() f = mapnik.Feature(mapnik.Context(), 1) f.add_geometries_from_wkt("POINT(-92.289595 34.746481)") ds.add_feature(f) #create the layer and add the data player = mapnik.Layer('airport_layer') player.srs = longlat.params() player.datasource = ds player.styles.append('airport point') m.layers.append(player) m.zoom_all() if hasattr(mapnik, 'Box2d'): bbox = mapnik.Box2d(*bounds) else: bbox = mapnik.Envelope(*bounds) # Our bounds above are in long/lat, but our map # is in spherical mercator, so we need to transform # the bounding box to mercator to properly position # the Map when we call `zoom_to_box()`
def _test_rgba_8bui_rendering(lbl, overview, rescale, clip): if rescale: lbl += ' Sc' if clip: lbl += ' Cl' ds = mapnik.PgRaster(dbname=MAPNIK_TEST_DBNAME, table='(select * from "River") foo', use_overviews=1 if overview else 0, prescale_rasters=rescale, clip_rasters=clip) fs = ds.featureset() feature = fs.next() eq_(feature['rid'], 1) lyr = mapnik.Layer('rgba_8bui') lyr.datasource = ds expenv = mapnik.Box2d(0, -210, 256, 0) env = lyr.envelope() # As the input size is a prime number both horizontally # and vertically, we expect the extent of the overview # tables to be a pixel wider than the original, whereas # the pixel size in geographical units depends on the # overview factor. So we start with the original pixel size # as base scale and multiply by the overview factor. # NOTE: the overview table extent only grows north and east pixsize = 1 # see gdalinfo river.tif tol = pixsize * max(overview.split(',')) if overview else 0 assert_almost_equal(env.minx, expenv.minx) assert_almost_equal(env.miny, expenv.miny, delta=tol) assert_almost_equal(env.maxx, expenv.maxx, delta=tol) assert_almost_equal(env.maxy, expenv.maxy) mm = mapnik.Map(256, 256) style = mapnik.Style() sym = mapnik.RasterSymbolizer() rule = mapnik.Rule() rule.symbols.append(sym) style.rules.append(rule) mm.append_style('foo', style) lyr.styles.append('foo') mm.layers.append(lyr) mm.zoom_to_box(expenv) im = mapnik.Image(mm.width, mm.height) t0 = time.time() # we want wall time to include IO waits mapnik.render(mm, im) lap = time.time() - t0 log('T ' + str(lap) + ' -- ' + lbl + ' E:full') expected = 'images/support/pgraster/%s-%s-%s-%s-box1.png' % ( lyr.name, lbl, overview, clip) compare_images(expected, im) # no data eq_(hexlify(im.view(3, 3, 1, 1).tostring()), b'00000000') eq_(hexlify(im.view(250, 250, 1, 1).tostring()), b'00000000') # full opaque river color eq_(hexlify(im.view(175, 118, 1, 1).tostring()), b'b9d8f8ff') # half-transparent pixel pxstr = hexlify(im.view(122, 138, 1, 1).tostring()).decode() apat = ".*(..)$" match = re.match(apat, pxstr) assert match, 'pixel ' + pxstr + ' does not match pattern ' + apat alpha = match.group(1) assert alpha != 'ff' and alpha != '00', \ 'unexpected full transparent/opaque pixel: ' + alpha # Now zoom over a portion of the env (1/10) newenv = mapnik.Box2d(166, -105, 191, -77) mm.zoom_to_box(newenv) t0 = time.time() # we want wall time to include IO waits im = mapnik.Image(mm.width, mm.height) mapnik.render(mm, im) lap = time.time() - t0 log('T ' + str(lap) + ' -- ' + lbl + ' E:1/10') expected = 'images/support/pgraster/%s-%s-%s-%s-box2.png' % ( lyr.name, lbl, overview, clip) compare_images(expected, im) # no data eq_(hexlify(im.view(255, 255, 1, 1).tostring()), b'00000000') eq_(hexlify(im.view(200, 40, 1, 1).tostring()), b'00000000') # full opaque river color eq_(hexlify(im.view(100, 168, 1, 1).tostring()), b'b9d8f8ff') # half-transparent pixel pxstr = hexlify(im.view(122, 138, 1, 1).tostring()).decode() apat = ".*(..)$" match = re.match(apat, pxstr) assert match, 'pixel ' + pxstr + ' does not match pattern ' + apat alpha = match.group(1) assert alpha != 'ff' and alpha != '00', \ 'unexpected full transparent/opaque pixel: ' + alpha
# Allow Overlaps and set opacity of marker point_symbolizer.allow_overlap = True point_symbolizer.opacity = 0.7 # add the point_symbolizer to the rule object r.symbols.append(point_symbolizer) # now add the rule(s) to the style s.rules.append(r) # Styles are added to the map m.append_style('My Style', s) # Projection from PostGIS-Layer-Data lyr = mapnik.Layer( 'Geometry from PostGIS', '+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0 +k=1.0 +units=m +nadgrids=@null +no_defs +over' ) # PostGIS-Connection + DB-Query lyr.datasource = mapnik2.PostGIS(host=hostname, user=db_user, password=db_pw, dbname=db_name, table=db_query) # Append Style to layer lyr.styles.append('My Style') # # END Layer 1 #
def getMapImage(osmFile, map_output): '''Uses the data from the osmFile to out a .png image of the area depicted by the input file''' if not HAS_MAPNIK: print('Error: Mapnik module is missing. ' + 'Please install for getting the image functionality.') return -2 print('Has Mapnik.') if osmFile == '': print 'Error: getMapImage::No File Recieved' return -1 else: print('OSM File: ' + osmFile) highwayList = dict({ "motorway": { 'width': 4, 'color': 'green', 'fontSize': 12 }, "trunk": { 'width': 3, 'color': 'green', 'fontSize': 11 }, "primary": { 'width': 1.5, 'color': '#0090ff', 'fontSize': 10 }, "secondary": { 'width': 0.8, 'color': '#ff00ff', 'fontSize': 8 }, "tertiary": { 'width': 0.42, 'color': '#000000', 'fontSize': 8 }, "residential": { 'width': 0.21, 'color': 'black', 'fontSize': 8 }, "living_street": { 'width': 0.21, 'color': 'black', 'fontSize': 8 }, "pedestrian": { 'width': 0.21, 'color': 'brown', 'fontSize': 8 }, "footway": { 'width': 0.21, 'color': 'brown', 'fontSize': 8 } }) m = mapnik.Map(1024, 1024) m.background = mapnik.Color('white') for highwayType in highwayList.keys(): styleType = mapnik.Style() print(styleType) rule = mapnik.Rule() rule.filter = mapnik.Expression('[highway]=' + "'" + highwayType + "'") stk = mapnik.Stroke() stk.color = mapnik.Color(highwayList[highwayType]['color']) stk.line_cap = mapnik.line_cap.ROUND_CAP stk.width = highwayList[highwayType]['width'] line_symbolizer = mapnik.LineSymbolizer(stk) rule.symbols.append(line_symbolizer) rule2 = mapnik.Rule() rule2.filter = mapnik.Expression('[highway]=' + "'" + highwayType + "'") text_symbolizer = mapnik.TextSymbolizer( mapnik.Expression("[name]"), "DejaVu Sans Book", highwayList[highwayType]['fontSize'], mapnik.Color('black')) text_symbolizer.halo_fill = mapnik.Color('white') rule2.symbols.append(text_symbolizer) styleType.rules.append(rule) styleType.rules.append(rule2) m.append_style(highwayType, styleType) ds = mapnik.Osm(file=osmFile) layer = mapnik.Layer('world') layer.datasource = ds for highwayType in highwayList.keys(): layer.styles.append(highwayType) m.layers.append(layer) m.zoom_all() mapnik.render_to_file(m, map_output, 'png') return os.system('xdg-open ' + map_output)
# Script to create an xml file to describe the National Atlas # hydrography layer. import mapnik m = mapnik.Map(0, 0) water_rule = mapnik.Rule() water_rule.filter = mapnik.Expression("[Feature]='Canal' or [Feature]='Lake'") water_rule.symbols.append(mapnik.PolygonSymbolizer(mapnik.Color(165, 191, 221))) marsh_rule = mapnik.Rule() marsh_rule.filter = mapnik.Expression("[Feature]='Swamp or Marsh'") marsh_color = mapnik.Color('#66AA66') marsh_rule.symbols.append(mapnik.PolygonSymbolizer(marsh_color)) marsh_rule.symbols.append(mapnik.LineSymbolizer(marsh_color, 2)) atlas_style = mapnik.Style() atlas_style.rules.append(water_rule) atlas_style.rules.append(marsh_rule) m.append_style('atlas', atlas_style) lyr = mapnik.Layer('National Atlas Hydro', "+proj=longlat +ellps=GRS80 +datum=NAD83 +no_defs") lyr.datasource = mapnik.Shapefile(file=r'D:\osgeopy-data\US\wtrbdyp010') lyr.styles.append('atlas') m.layers.append(lyr) mapnik.save_map(m, r'D:\osgeopy-data\US\national_atlas_hydro.xml')
# Script demonstrating how to use multiple rules in a mapnik style. ##################### The first part is from listing 13.8. import mapnik # Create the map object. srs = "+proj=longlat +ellps=GRS80 +datum=NAD83 +no_defs" m = mapnik.Map(800, 600, srs) m.zoom_to_box(mapnik.Box2d(-90.3, 29.7, -89.5, 30.3)) # Create a layer from a shapefile. tiger_fn = r'D:\osgeopy-data\Louisiana\tiger_la_water_CENSUS_2006' tiger_shp = mapnik.Shapefile(file=tiger_fn) tiger_lyr = mapnik.Layer('Tiger') tiger_lyr.datasource = tiger_shp # Create a polygon fill symbol. water_color = mapnik.Color(165, 191, 221) water_fill_sym = mapnik.PolygonSymbolizer(water_color) # Create a symbology style and add it to the layer. tiger_rule = mapnik.Rule() tiger_rule.symbols.append(water_fill_sym) tiger_style = mapnik.Style() tiger_style.rules.append(tiger_rule) m.append_style('tiger', tiger_style) # Add the style and layer to the map. tiger_lyr.styles.append('tiger')
# create a style s = mapnik.Style() r = mapnik.Rule() polygon_symbolizer = mapnik.PolygonSymbolizer() polygon_symbolizer.fill = mapnik.Color('#f2eff9') r.symbols.append(polygon_symbolizer) line_symbolizer = mapnik.LineSymbolizer() line_symbolizer.stroke = mapnik.Color('rgb(50%,50%,50%)') line_symbolizer.stroke_width = 0.1 r.symbols.append(line_symbolizer) s.rules.append(r) # add style to map m.append_style('My Style', s) # create datasource ds = mapnik.Shapefile(file='../data/TM_WORLD_BORDERS-0.3.shp') # create a layer layer = mapnik.Layer('world') # a new layer called world layer.datasource = ds layer.styles.append('My Style') # render map m.layers.append(layer) m.zoom_all() mapnik.render_to_file(m, 'world.png', 'png')
for country in countryList.findall("country"): name = country.find("name").text iso3 = country.find("iso3").text logging.info("Processing %s" % name) # Create Datasource query = '(SELECT * FROM GAUL_2010_2 WHERE ISO3 = "%s")' % iso3 datasource = mapnik.SQLite(file=dbPath, table=query, geometry_field="Geometry", key_field="PK_UID", use_spatial_index=False) # Create layer layer = mapnik.Layer("boundaries") layer.datasource = datasource layer.styles.append("boundariesStyle") # Calculate image output size envelope = datasource.envelope() dLong = envelope.maxx - envelope.minx dLat = envelope.maxy - envelope.miny aspectRatio = dLong / dLat if dLong > dLat: width = max_img_size height = int(width / aspectRatio) elif dLat > dLong: height = max_img_size width = int(aspectRatio * height)
def test_psql_error_should_give_back_connections_opened_for_lower_layers_to_the_pool( ): map1 = mapnik.Map(600, 300) s = mapnik.Style() r = mapnik.Rule() r.symbols.append(mapnik.PolygonSymbolizer()) s.rules.append(r) map1.append_style('style', s) # This layer will fail after a while buggy_s = mapnik.Style() buggy_r = mapnik.Rule() buggy_r.symbols.append(mapnik.PolygonSymbolizer()) buggy_r.filter = mapnik.Filter("[fips] = 'FR'") buggy_s.rules.append(buggy_r) map1.append_style('style for buggy layer', buggy_s) buggy_layer = mapnik.Layer('this layer is buggy at runtime') # We ensure the query wille be long enough buggy_layer.datasource = mapnik.PostGIS( dbname=MAPNIK_TEST_DBNAME, table= '(SELECT geom as geom, pg_sleep(0.1), fips::int from world_merc) as failure_tabl', max_async_connection=2, max_size=2, asynchronous_request=True, geometry_field='geom') buggy_layer.styles.append('style for buggy layer') # The query for this layer will be sent, then the previous layer will raise an exception before results are read forced_canceled_layer = mapnik.Layer( 'this layer will be canceled when an exception stops map rendering' ) forced_canceled_layer.datasource = mapnik.PostGIS( dbname=MAPNIK_TEST_DBNAME, table='world_merc', max_async_connection=2, max_size=2, asynchronous_request=True, geometry_field='geom') forced_canceled_layer.styles.append('style') map1.layers.append(buggy_layer) map1.layers.append(forced_canceled_layer) map1.zoom_all() map2 = mapnik.Map(600, 300) map2.background = mapnik.Color('steelblue') s = mapnik.Style() r = mapnik.Rule() r.symbols.append(mapnik.LineSymbolizer()) r.symbols.append(mapnik.LineSymbolizer()) s.rules.append(r) map2.append_style('style', s) layer1 = mapnik.Layer('layer1') layer1.datasource = mapnik.PostGIS(dbname=MAPNIK_TEST_DBNAME, table='world_merc', max_async_connection=2, max_size=2, asynchronous_request=True, geometry_field='geom') layer1.styles.append('style') map2.layers.append(layer1) map2.zoom_all() # We expect this to trigger a PSQL error try: mapnik.render_to_file(map1, '/tmp/mapnik-postgis-test-map1.png', 'png') # Test must fail if error was not raised just above eq_(False, True) except RuntimeError: pass # This used to raise an exception before correction of issue 2042 mapnik.render_to_file(map2, '/tmp/mapnik-postgis-test-map2.png', 'png')
#JAPAN ADMINISTRATIVE s = mapnik.Style() r = mapnik.Rule() polygon_symbolizer = mapnik.PolygonSymbolizer() polygon_symbolizer.fill = mapnik.Color('#a0a0a0') r.symbols.append(polygon_symbolizer) line_symbolizer = mapnik.LineSymbolizer(mapnik.Color('yellow'), 5) line_symbolizer.stroke_width = 50.0 r.symbols.append(line_symbolizer) s.rules.append(r) m.append_style('My Style1', s) ds = mapnik.Shapefile(file="JPN_adm/JPN_adm0.shp") layer = mapnik.Layer('jpn_adm') layer.datasource = ds layer.styles.append('My Style1') m.layers.append(layer) #JAPAN ADMINISTRATIVE 2 s = mapnik.Style() r = mapnik.Rule() polygon_symbolizer = mapnik.PolygonSymbolizer() polygon_symbolizer.fill = mapnik.Color('#d9d9d9') r.symbols.append(polygon_symbolizer) line_symbolizer = mapnik.LineSymbolizer(mapnik.Color('green'), 1) r.symbols.append(line_symbolizer) s.rules.append(r)
def tile(request, version, shapefile_id, zoom, x, y): shapefile = None try: if version != "1.0": raise Http404 try: shapefile = Shapefile.objects.get(id=shapefile_id) except Shapefile.DoesNotExist: raise Http404 zoom = int(zoom) x = int(x) y = int(y) if zoom < 0 or zoom > MAX_ZOOM_LEVEL: raise Http404 xExtent = _unitsPerPixel(zoom) * TILE_WIDTH yExtent = _unitsPerPixel(zoom) * TILE_HEIGHT minLong = xExtent * x - 180.0 minLat = yExtent * y - 90.0 maxLong = minLong + xExtent maxLat = minLat + xExtent #if (minLong < -180 or maxLong > 180 or #minLat < -90 or maxLat > 90): #raise Http404 map = mapnik.Map(TILE_WIDTH, TILE_HEIGHT, "+proj=longlat +datum=WGS84") map.background = mapnik.Color("#7391ad") dbSettings = settings.DATABASES['default'] datasource = mapnik.PostGIS(host='localhost', user='******', password='******', dbname='spatial', table='"shapeEditor_basemap"', srid=4326, geometry_field="geometry", geometry_table='"shapeEditor_basemap"') baseLayer = mapnik.Layer("baseLayer") baseLayer.datasource = datasource baseLayer.styles.append("baseLayerStyle") rule = mapnik.Rule() rule.symbols.append(mapnik.PolygonSymbolizer(mapnik.Color("#b5d19c"))) rule.symbols.append(mapnik.LineSymbolizer(mapnik.Color("#000000"), 0.1)) style = mapnik.Style() style.rules.append(rule) map.append_style("baseLayerStyle", style) map.layers.append(baseLayer) geometryField = utils.calcGeometryField(shapefile.geom_type) query = '(select ' + geometryField + ' from "shapeEditor_feature" where' + ' shapefile_id=' + str( shapefile.id) + ') as geom' datasource = mapnik.PostGIS(host='localhost', user='******', password='******', dbname='spatial', table=query, srid=4326, geometry_field=geometryField, geometry_table='"shapeEditor_feature"') featureLayer = mapnik.Layer("featureLayer") featureLayer.datasource = datasource featureLayer.styles.append("featureLayerStyle") rule = mapnik.Rule() if shapefile.geom_type in ["Point", "MultiPoint"]: rule.symbols.append(mapnik.PointSymbolizer()) elif shapefile.geom_type in ["LineString", "MultiLineString"]: rule.symbols.append( mapnik.LineSymbolizer(mapnik.Color("#000000"), 0.5)) elif shapefile.geom_type in ["Polygon", "MultiPolygon"]: rule.symbols.append( mapnik.PolygonSymbolizer(mapnik.Color("#f7edee"))) rule.symbols.append( mapnik.LineSymbolizer(mapnik.Color("#000000"), 0.5)) style = mapnik.Style() style.rules.append(rule) map.append_style("featureLayerStyle", style) map.layers.append(featureLayer) map.zoom_to_box(mapnik.Box2d(minLong, minLat, maxLong, maxLat)) image = mapnik.Image(TILE_WIDTH, TILE_HEIGHT) mapnik.render(map, image) imageData = image.tostring('png') return HttpResponse(imageData, content_type="image/png") except: traceback.print_exc() return HttpResponse("")
r.symbols.append(text_sym) point_sym = mapnik.PointSymbolizer() point_sym.allow_overlap = True r.symbols.append(point_sym) s.rules.append(r) m.append_style("airport point", s) ds = mapnik.MemoryDatasource() f = mapnik.Feature(mapnik.Context(), 1) #f["NAME"] = "JUANDA" f.add_geometries_from_wkt("POINT(-7.3788851 112.7851004)") ds.add_feature(f) player = mapnik.Layer("airport_layer") player.datasource = ds player.styles.append("airport point") m.layers.append(player) m.append_style('My Style', s) ds = mapnik.Shapefile(file="SHP_Indonesia_provinsi/INDONESIA_PROP.shp") layer = mapnik.Layer('propinsi') layer.datasource = ds layer.styles.append('My Style') m.layers.append(layer) m.zoom_all() mapnik.render_to_file(m, 'T5_Muhammad-Habibi_04315004-point.pdf', 'pdf') print "rendered image to 'T5_Muhammad-Habibi_04315004-point.png' "
import os.path import mapnik symbolizer = mapnik.PolygonSymbolizer(mapnik.Color("darkgreen")) rule = mapnik.Rule() rule.symbols.append(symbolizer) style = mapnik.Style() style.rules.append(rule) layer = mapnik.Layer("mapLayer") layer.datasource = mapnik.Shapefile(file="TM_WORLD_BORDERS-0.3.shp") layer.styles.append("mapStyle") map = mapnik.Map(800, 400) map.background = mapnik.Color("steelblue") map.append_style("mapStyle", style) map.layers.append(layer) map.zoom_all() mapnik.render_to_file(map, "map.png", "png")
def _test_dataraster_16bsi_rendering(lbl, overview, rescale, clip): if rescale: lbl += ' Sc' if clip: lbl += ' Cl' ds = mapnik.PgRaster(dbname=MAPNIK_TEST_DBNAME, table='"dataRaster"', band=1, use_overviews=1 if overview else 0, prescale_rasters=rescale, clip_rasters=clip) fs = ds.featureset() feature = fs.next() eq_(feature['rid'], 1) lyr = mapnik.Layer('dataraster_16bsi') lyr.datasource = ds expenv = mapnik.Box2d(-14637, 3903178, 1126863, 4859678) env = lyr.envelope() # As the input size is a prime number both horizontally # and vertically, we expect the extent of the overview # tables to be a pixel wider than the original, whereas # the pixel size in geographical units depends on the # overview factor. So we start with the original pixel size # as base scale and multiply by the overview factor. # NOTE: the overview table extent only grows north and east pixsize = 500 # see gdalinfo dataraster.tif pixsize = 2497 # see gdalinfo dataraster-small.tif tol = pixsize * max(overview.split(',')) if overview else 0 assert_almost_equal(env.minx, expenv.minx) assert_almost_equal(env.miny, expenv.miny, delta=tol) assert_almost_equal(env.maxx, expenv.maxx, delta=tol) assert_almost_equal(env.maxy, expenv.maxy) mm = mapnik.Map(256, 256) style = mapnik.Style() col = mapnik.RasterColorizer() col.default_mode = mapnik.COLORIZER_DISCRETE col.add_stop(0, mapnik.Color(0x40, 0x40, 0x40, 255)) col.add_stop(10, mapnik.Color(0x80, 0x80, 0x80, 255)) col.add_stop(20, mapnik.Color(0xa0, 0xa0, 0xa0, 255)) sym = mapnik.RasterSymbolizer() sym.colorizer = col rule = mapnik.Rule() rule.symbols.append(sym) style.rules.append(rule) mm.append_style('foo', style) lyr.styles.append('foo') mm.layers.append(lyr) mm.zoom_to_box(expenv) im = mapnik.Image(mm.width, mm.height) t0 = time.time() # we want wall time to include IO waits mapnik.render(mm, im) lap = time.time() - t0 log('T ' + str(lap) + ' -- ' + lbl + ' E:full') # no data eq_(im.view(1, 1, 1, 1).tostring(), b'\x00\x00\x00\x00') eq_(im.view(255, 255, 1, 1).tostring(), b'\x00\x00\x00\x00') eq_(im.view(195, 116, 1, 1).tostring(), b'\x00\x00\x00\x00') # A0A0A0 eq_(im.view(100, 120, 1, 1).tostring(), b'\xa0\xa0\xa0\xff') eq_(im.view(75, 80, 1, 1).tostring(), b'\xa0\xa0\xa0\xff') # 808080 eq_(im.view(74, 170, 1, 1).tostring(), b'\x80\x80\x80\xff') eq_(im.view(30, 50, 1, 1).tostring(), b'\x80\x80\x80\xff') # 404040 eq_(im.view(190, 70, 1, 1).tostring(), b'\x40\x40\x40\xff') eq_(im.view(140, 170, 1, 1).tostring(), b'\x40\x40\x40\xff') # Now zoom over a portion of the env (1/10) newenv = mapnik.Box2d(273663, 4024478, 330738, 4072303) mm.zoom_to_box(newenv) t0 = time.time() # we want wall time to include IO waits mapnik.render(mm, im) lap = time.time() - t0 log('T ' + str(lap) + ' -- ' + lbl + ' E:1/10') # nodata eq_(hexlify(im.view(255, 255, 1, 1).tostring()), b'00000000') eq_(hexlify(im.view(200, 254, 1, 1).tostring()), b'00000000') # A0A0A0 eq_(hexlify(im.view(90, 232, 1, 1).tostring()), b'a0a0a0ff') eq_(hexlify(im.view(96, 245, 1, 1).tostring()), b'a0a0a0ff') # 808080 eq_(hexlify(im.view(1, 1, 1, 1).tostring()), b'808080ff') eq_(hexlify(im.view(128, 128, 1, 1).tostring()), b'808080ff') # 404040 eq_(hexlify(im.view(255, 0, 1, 1).tostring()), b'404040ff')
# Script to add the roads and city outline to the mapnik map. ##################### The first part is from listing 13.9. import mapnik # Create the map object. srs = "+proj=longlat +ellps=GRS80 +datum=NAD83 +no_defs" m = mapnik.Map(800, 600, srs) m.zoom_to_box(mapnik.Box2d(-90.3, 29.7, -89.5, 30.3)) # Create a layer from a shapefile. tiger_fn = r'D:\osgeopy-data\Louisiana\tiger_la_water_CENSUS_2006' tiger_shp = mapnik.Shapefile(file=tiger_fn) tiger_lyr = mapnik.Layer('Tiger') tiger_lyr.datasource = tiger_shp # Create a polygon fill symbol. water_color = mapnik.Color(165, 191, 221) water_fill_sym = mapnik.PolygonSymbolizer(water_color) # Create a symbology style and add it to the layer. tiger_rule = mapnik.Rule() tiger_rule.symbols.append(water_fill_sym) tiger_style = mapnik.Style() tiger_style.rules.append(tiger_rule) m.append_style('tiger', tiger_style) # Add the style and layer to the map. tiger_lyr.styles.append('tiger')
def _test_rgb_8bui_rendering(lbl, tnam, overview, rescale, clip): if rescale: lbl += ' Sc' if clip: lbl += ' Cl' ds = mapnik.PgRaster(dbname=MAPNIK_TEST_DBNAME, table=tnam, use_overviews=1 if overview else 0, prescale_rasters=rescale, clip_rasters=clip) fs = ds.featureset() feature = fs.next() eq_(feature['rid'], 1) lyr = mapnik.Layer('rgba_8bui') lyr.datasource = ds expenv = mapnik.Box2d(-12329035.7652168, 4508650.39854396, -12328653.0279471, 4508957.34625536) env = lyr.envelope() # As the input size is a prime number both horizontally # and vertically, we expect the extent of the overview # tables to be a pixel wider than the original, whereas # the pixel size in geographical units depends on the # overview factor. So we start with the original pixel size # as base scale and multiply by the overview factor. # NOTE: the overview table extent only grows north and east pixsize = 2 # see gdalinfo nodata-edge.tif tol = pixsize * max(overview.split(',')) if overview else 0 assert_almost_equal(env.minx, expenv.minx, places=0) assert_almost_equal(env.miny, expenv.miny, delta=tol) assert_almost_equal(env.maxx, expenv.maxx, delta=tol) assert_almost_equal(env.maxy, expenv.maxy, places=0) mm = mapnik.Map(256, 256) style = mapnik.Style() sym = mapnik.RasterSymbolizer() rule = mapnik.Rule() rule.symbols.append(sym) style.rules.append(rule) mm.append_style('foo', style) lyr.styles.append('foo') mm.layers.append(lyr) mm.zoom_to_box(expenv) im = mapnik.Image(mm.width, mm.height) t0 = time.time() # we want wall time to include IO waits mapnik.render(mm, im) lap = time.time() - t0 log('T ' + str(lap) + ' -- ' + lbl + ' E:full') expected = 'images/support/pgraster/%s-%s-%s-%s-%s-box1.png' % ( lyr.name, tnam, lbl, overview, clip) compare_images(expected, im) # no data eq_(hexlify(im.view(3, 16, 1, 1).tostring()), b'00000000') eq_(hexlify(im.view(128, 16, 1, 1).tostring()), b'00000000') eq_(hexlify(im.view(250, 16, 1, 1).tostring()), b'00000000') eq_(hexlify(im.view(3, 240, 1, 1).tostring()), b'00000000') eq_(hexlify(im.view(128, 240, 1, 1).tostring()), b'00000000') eq_(hexlify(im.view(250, 240, 1, 1).tostring()), b'00000000') # dark brown eq_(hexlify(im.view(174, 39, 1, 1).tostring()), b'c3a698ff') # dark gray eq_(hexlify(im.view(195, 132, 1, 1).tostring()), b'575f62ff') # Now zoom over a portion of the env (1/10) newenv = mapnik.Box2d(-12329035.7652168, 4508926.651484220, -12328997.49148983, 4508957.34625536) mm.zoom_to_box(newenv) t0 = time.time() # we want wall time to include IO waits im = mapnik.Image(mm.width, mm.height) mapnik.render(mm, im) lap = time.time() - t0 log('T ' + str(lap) + ' -- ' + lbl + ' E:1/10') expected = 'images/support/pgraster/%s-%s-%s-%s-%s-box2.png' % ( lyr.name, tnam, lbl, overview, clip) compare_images(expected, im) # no data eq_(hexlify(im.view(3, 16, 1, 1).tostring()), b'00000000') eq_(hexlify(im.view(128, 16, 1, 1).tostring()), b'00000000') eq_(hexlify(im.view(250, 16, 1, 1).tostring()), b'00000000') # black eq_(hexlify(im.view(3, 42, 1, 1).tostring()), b'000000ff') eq_(hexlify(im.view(3, 134, 1, 1).tostring()), b'000000ff') eq_(hexlify(im.view(3, 244, 1, 1).tostring()), b'000000ff') # gray eq_(hexlify(im.view(135, 157, 1, 1).tostring()), b'4e555bff') # brown eq_(hexlify(im.view(195, 223, 1, 1).tostring()), b'f2cdbaff')
the_filter = '[PRECINCT] = {0}'.format(precinct) color = '#FFFFFF' outline_color = '#000000' rule = mapnik.Rule() rule.filter = mapnik.Filter(the_filter) symbolizer = mapnik.PolygonSymbolizer(mapnik.Color(color)) rule.symbols.append(symbolizer) precinct_style.rules.append(rule) symbolizer = mapnik.LineSymbolizer() symbolizer.stroke = mapnik.Stroke(mapnik.Color(outline_color), 1) rule.symbols.append(symbolizer) precinct_style.rules.append(rule) layer1 = mapnik.Layer("Precinct Layer") layer1.datasource = mapnik.Shapefile(file="data/Voter_Precinct.shp") layer1.styles.append("Map Style") # Add another layer with a record from the Roads file rule = mapnik.Rule() rule.filter = mapnik.Filter('[OBJECTID] = 324') symbolizer = mapnik.PolygonSymbolizer(mapnik.Color('#FF7700')) rule.symbols.append(symbolizer) roads_style.rules.append(rule) symbolizer = mapnik.LineSymbolizer() symbolizer.stroke = mapnik.Stroke(mapnik.Color('#FF7700'), 1) rule.symbols.append(symbolizer) roads_style.rules.append(rule)
def _test_data_subquery(lbl, pixtype, value): # # 3 8 13 # +---+---+---+ # 3 | v | v | v | NOTE: writes different values # +---+---+---+ in 13,8 and 8,13 # 8 | v | v | a | # +---+---+---+ # 13 | v | b | v | # +---+---+---+ # val_a = value / 3 val_b = val_a * 2 sql = "(select 3 as i, " \ " ST_SetValues(" \ " ST_SetValues(" \ " ST_AsRaster(" \ " ST_MakeEnvelope(0,0,14,14), " \ " 1.0, -1.0, '%s', %s" \ " ), " \ " 11, 6, 5, 5, %s::float8" \ " )," \ " 6, 11, 5, 5, %s::float8" \ " ) as \"R\"" \ ") as foo" % (pixtype, value, val_a, val_b) overview = '' rescale = 0 clip = 0 if rescale: lbl += ' Sc' if clip: lbl += ' Cl' ds = mapnik.PgRaster(dbname=MAPNIK_TEST_DBNAME, table=sql, raster_field='R', use_overviews=0 if overview else 0, band=1, prescale_rasters=rescale, clip_rasters=clip) fs = ds.featureset() feature = fs.next() eq_(feature['i'], 3) lyr = mapnik.Layer('data_subquery') lyr.datasource = ds expenv = mapnik.Box2d(0, 0, 14, 14) env = lyr.envelope() assert_almost_equal(env.minx, expenv.minx, places=0) assert_almost_equal(env.miny, expenv.miny, places=0) assert_almost_equal(env.maxx, expenv.maxx, places=0) assert_almost_equal(env.maxy, expenv.maxy, places=0) mm = mapnik.Map(15, 15) style = mapnik.Style() col = mapnik.RasterColorizer() col.default_mode = mapnik.COLORIZER_DISCRETE col.add_stop(val_a, mapnik.Color(0xff, 0x00, 0x00, 255)) col.add_stop(val_b, mapnik.Color(0x00, 0xff, 0x00, 255)) col.add_stop(value, mapnik.Color(0x00, 0x00, 0xff, 255)) sym = mapnik.RasterSymbolizer() sym.colorizer = col rule = mapnik.Rule() rule.symbols.append(sym) style.rules.append(rule) mm.append_style('foo', style) lyr.styles.append('foo') mm.layers.append(lyr) mm.zoom_to_box(expenv) im = mapnik.Image(mm.width, mm.height) t0 = time.time() # we want wall time to include IO waits mapnik.render(mm, im) lap = time.time() - t0 log('T ' + str(lap) + ' -- ' + lbl + ' E:full') expected = 'images/support/pgraster/%s-%s-%s-%s.png' % (lyr.name, lbl, pixtype, value) compare_images(expected, im)
#!/usr/bin/env python3 # -*- coding: utf-8 -*- ############################################################################### import os import mapnik stylesheet = '/gdata/world_population.xml' m = mapnik.Map(600, 300) mapnik.load_map(m, stylesheet) m.background = mapnik.Color('steelblue') s = mapnik.Style() r = mapnik.Rule() polygon_symbolizer = mapnik.PolygonSymbolizer() polygon_symbolizer.fill = mapnik.Color('#f2eff9') r.symbols.append(polygon_symbolizer) s.rules.append(r) m.append_style('My Style2', s) ############################################################################### wkt_geom = 'POLYGON ((5 21,-18 -10, -16 -52, 37 -21, 5 21))' csv_string = ''' wkt,Name "{wkt_geom}","test" '''.format(wkt_geom=wkt_geom) ds = mapnik.Datasource(**{"type": "csv", "inline": csv_string}) layer2 = mapnik.Layer('world', '+proj=latlong +datum=WGS84') layer2.datasource = ds layer2.styles.append('My Style2') m.layers.append(layer2) m.zoom_all() mapnik.render_to_file(m, 'xx_ds_pt.png', 'png')
def tile(request, version, shapefile_id, zoom, x, y): try: if version != "1.0": raise Http404 try: shapefile = Shapefile.objects.get(id=shapefile_id) except Shapefile.DoesNotExist: raise Http404 zoom = int(zoom) x = int(x) y = int(y) if zoom < 0 or zoom > MAX_ZOOM_LEVEL: raise Http404 xExtent = _unitsPerPixel(zoom) * TILE_WIDTH yExtent = _unitsPerPixel(zoom) * TILE_HEIGHT minLong = x * xExtent - 180.0 minLat = y * yExtent - 90.0 maxLong = minLong + xExtent maxLat = minLat + yExtent if (minLong < -180 or maxLong > 180 or minLat < -90 or maxLat > 90): print "Map extent out of bounds:",minLong,minLat,maxLong,maxLat raise Http404 ####################################################### map = mapnik.Map(TILE_WIDTH, TILE_HEIGHT, str("+proj=longlat +datum=WGS84")) map.background = mapnik.Color(str("#7391ad")) dbSettings = settings.DATABASES['default'] datasource = mapnik.PostGIS(user=str(dbSettings['USER']),password=str(dbSettings['PASSWORD']), dbname=str(dbSettings['NAME']),table='tms_basemap', srid=4326, geometry_field="geometry", geometry_table='tms_basemap', port=5433) baseLayer = mapnik.Layer(str("baseLayer")) baseLayer.datasource = datasource baseLayer.styles.append(str("baseLayerStyle")) rule = mapnik.Rule() rule.symbols.append( mapnik.PolygonSymbolizer(mapnik.Color(str("#b5d19c")))) rule.symbols.append( mapnik.LineSymbolizer(mapnik.Color(str("#404040")), 0.2)) style = mapnik.Style() style.rules.append(rule) map.append_style(str("baseLayerStyle"), style) #### map.layers.append(baseLayer) geometry_field = \ utils.calc_geometry_field(shapefile.geom_type) query = '(SELECT ' + geometry_field \ + ' FROM "shared_feature" WHERE' \ + ' shapefile_id = ' + str(shapefile.id) + ') as geom' print query print dbSettings['USER'],dbSettings['PASSWORD'],dbSettings['NAME'],query,geometry_field datasource = \ mapnik.PostGIS(user=dbSettings['USER'], password=dbSettings['PASSWORD'], dbname=dbSettings['NAME'], port=dbSettings['PORT'], srid=4326, table=query, geometry_field=geometry_field, geometry_table='shared_feature', ) featureLayer = mapnik.Layer(str("featureLayer")) featureLayer.datasource = datasource featureLayer.styles.append(str("featureLayerStyle")) rule = mapnik.Rule() if shapefile.geom_type in ["Point", "MultiPoint"]: rule.symbols.append(mapnik.PointSymbolizer()) elif shapefile.geom_type in ["LineString", "MultiLineString"]: rule.symbols.append( mapnik.LineSymbolizer(mapnik.Color("#000000"), 0.5)) elif shapefile.geom_type in ["Polygon", "MultiPolygon"]: rule.symbols.append( mapnik.PolygonSymbolizer(mapnik.Color(str("#f7edee")))) rule.symbols.append( mapnik.LineSymbolizer(mapnik.Color(str("#000000")), 0.5)) style = mapnik.Style() style.rules.append(rule) map.append_style(str("featureLayerStyle"), style) map.layers.append(featureLayer) map.zoom_to_box(mapnik.Box2d(minLong, minLat, maxLong, maxLat)) image = mapnik.Image(TILE_WIDTH, TILE_HEIGHT) mapnik.render(map, image) imageData = image.tostring(str('png')) print imageData return HttpResponse(imageData, content_type="image/png") except: traceback.print_exc() return HttpResponse("Error")
# Script to draw a topo map with a hillshade underneath. import mapnik srs = '+proj=utm +zone=10 +ellps=GRS80 +datum=NAD83 +units=m +no_defs' m = mapnik.Map(1200, 1200, srs) m.zoom_to_box(mapnik.Box2d(558800, 5112200, 566600, 5120500)) hillshade_lyr = mapnik.Layer('Hillshade', srs) hillshade_raster = mapnik.Gdal( file=r'D:\osgeopy-data\Washington\dem\sthelens_hillshade.tif') hillshade_lyr.datasource = hillshade_raster hillshade_rule = mapnik.Rule() hillshade_rule.symbols.append(mapnik.RasterSymbolizer()) hillshade_style = mapnik.Style() hillshade_style.rules.append(hillshade_rule) m.append_style('hillshade', hillshade_style) hillshade_lyr.styles.append('hillshade') topo_lyr = mapnik.Layer('Topo', srs) topo_raster = mapnik.Gdal(file=r'D:\osgeopy-data\Washington\dem\st_helens.tif') topo_lyr.datasource = topo_raster topo_sym = mapnik.RasterSymbolizer() topo_sym.opacity = 0.6 #A topo_rule = mapnik.Rule() topo_rule.symbols.append(topo_sym) topo_style = mapnik.Style() topo_style.rules.append(topo_rule)
def map_image(zoom, left, bottom, right, top, line, orientation='n', highres=True): mapfile = settings.MAPNIK_STYLES + "mapnik2normal.xml" if orientation != 'n': mapfile = settings.MAPNIK_STYLES + "mapnik2orlice_%s.xml" % str(orientation) imgx, imgy = get_image_size(zoom, top, left, bottom, right) if orientation in ('w', 'e'): imgx, imgy = imgy, imgx if highres: mapfile = settings.MAPNIK_STYLES + "mapnik2print.xml" if orientation != 'n': mapfile = settings.MAPNIK_STYLES + "mapnik2print_orlice_%s.xml" % str(orientation) imgx = 2*imgx imgy = 2*imgy m = mapnik.Map(imgx, imgy) mapnik.load_map(m, mapfile) prj = mapnik.Projection('+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0' ' +k=1.0 +units=m +nadgrids=@null +no_defs +over') # North on top n0 = prj.forward(mapnik.Coord(left, bottom)) n1 = prj.forward(mapnik.Coord(right, top)) # East on top e0 = mapnik.Coord(-n0.y, n0.x) e1 = mapnik.Coord(-n1.y, n1.x) # South on top s0 = mapnik.Coord(-n1.x, -n1.y) s1 = mapnik.Coord(-n0.x, -n0.y) # West on top w0 = mapnik.Coord(-e1.x, -e1.y) w1 = mapnik.Coord(-e0.x, -e0.y) # bottom_left = prj.forward(mapnik.Coord(left, bottom)) # top_right = prj.forward(mapnik.Coord(right, top)) boxes = {'n': mapnik.Box2d(n0.x, n0.y, n1.x, n1.y), 'e': mapnik.Box2d(e0.x, e0.y, e1.x, e1.y), 's': mapnik.Box2d(s0.x, s0.y, s1.x, s1.y), 'w': mapnik.Box2d(w0.x, w0.y, w1.x, w1.y) } if line: gpxstyle = mapnik.Style() gpxrule = mapnik.Rule() lns = mapnik.LineSymbolizer() stroke = mapnik.Stroke() stroke.color = mapnik.Color('#FF6600') if highres: stroke.width = 10 else: stroke.width = 5 stroke.opacity = 0.9 stroke.line_join = mapnik.line_join.names['round'] stroke.line_cap = mapnik.line_cap.names['round'] lns.stroke = stroke gpxrule.symbols.append(lns) gpxstyle.rules.append(gpxrule) m.append_style('gpxstyle', gpxstyle) gpxlayer = mapnik.Layer('gpx') gpxlayer.datasource = mapnik.Ogr(file=line, layer='OGRGeoJSON') gpxlayer.styles.append('gpxstyle') m.layers.append(gpxlayer) bbox = boxes[orientation] m.zoom_to_box(bbox) im = mapnik.Image(imgx, imgy) mapnik.render(m, im) return Image.open(StringIO(im.tostring('png')))
# Create the rule and style obj r = mapnik.Rule() s = mapnik.Style() # Set the land polygone polyStyle = mapnik.PolygonSymbolizer(mapnik.Color("darkred")) pointStyle = mapnik.PointSymbolizer(mapnik.PathExpression(file_symbol)) r.symbols.append(polyStyle) r.symbols.append(pointStyle) s.rules.append(r) map.append_style("mapStyle", s) # Adding point layer layerPoint = mapnik.Layer("pointLayer") layerPoint.datasource = mapnik.Shapefile(file=os.path.join("data", "map.shp")) layerPoint.styles.append("mapStyle") # Adding polygon layerPoly = mapnik.Layer("polyLayer") layerPoly.datasource = mapnik.Shapefile( file=os.path.join("data", "ne_110m_land.shp")) layerPoly.styles.append("mapStyle") # Add layers to map map.layers.append(layerPoly) map.layers.append(layerPoint) # Set boundaries for the Netherlands
# Instanciate a layer. The parameters depend on the type of data: # shape: # type='shape' # file='/path/to/shape' # raster: # type='raster' # file='/path/to/raster' # postgis: # type='postgis' # host='127.0.0.1' # dbname='mydatabase' # user='******' # password='******' # table= TODO provpoly_lyr = mapnik.Layer('Provinces') provpoly_lyr.srs = "+proj=lcc +ellps=GRS80 +lat_0=49 +lon_0=-95 +lat+1=49 +lat_2=77 +datum=NAD83 +units=m +no_defs" provpoly_lyr.datasource = mapnik.Shapefile(file=path.join( root, '../data/boundaries'), encoding='latin1') # We then define a style for the layer. A layer can have one or many styles. # Styles are named, so they can be shared across different layers. # Multiple styles per layer behaves functionally like multiple layers. The # data is completely re-scanned for each style within one layer, and a style # will be drawn entirely "above" the previous one. Performance wise using # multiple styles in one layer is the same has having multiple layers. # The paradigm is useful mostly as a convenience. provpoly_style = mapnik.Style()
diseases = ("cchf", "chik", "deng", "hat", "melio", "nwcl", "owcl", "scrub") diseases = ("hat", "nwcl", "owcl") variants = ("1A", "1B", "1C", "2C", "2D", "3B", "4A", "5A", "6A") variants = ("3B", "4A", "5A", "6A") for disease in diseases: for variant in variants: geotiff = "all/results/" + disease + "_" + variant + "/prediction_uncertainty_masked.tif" png = "all/results/" + disease + "_" + variant + "/prediction_uncertainty_masked.png" symbolizer = mapnik.RasterSymbolizer() colorizer = mapnik.RasterColorizer( default_mode=mapnik.COLORIZER_LINEAR, default_color=mapnik.Color("transparent")) symbolizer.colorizer = colorizer colorizer.add_stop(-9999.0, mapnik.Color("#000000")) colorizer.add_stop(0.0, mapnik.Color("#d4e7f4")) colorizer.add_stop(1.0, mapnik.Color("#5f8098")) colorizer.add_stop(9999.0, mapnik.Color("#eaeaea")) style = mapnik.Style() rule = mapnik.Rule() rule.symbols.append(symbolizer) style.rules.append(rule) layer = mapnik.Layer("raster") layer.datasource = mapnik.Gdal(file=geotiff, nodata=-9999, band=1) layer.styles.append("raster") world = mapnik.Map(1656, 667) world.append_style("raster", style) world.layers.append(layer) world.zoom_all() mapnik.render_to_file(world, png, 'png')