def __add_manholes(self, layers, styles): "Add manhole layer and styles." # Select the manholes that are part of this sewerage. manholes = Manhole.objects.filter(sewerage__pk=self.id) # Define a style. style = mapnik.Style() # Style the `normal` manholes. rule = mapnik.Rule() rule.filter = mapnik.Filter("[sink] != 1") symbol = mapnik.PointSymbolizer() symbol.allow_overlap = True rule.symbols.append(symbol) style.rules.append(rule) # Style the sink. rule = mapnik.Rule() rule.filter = mapnik.Filter("[sink] = 1") symbol = mapnik.PointSymbolizer( str(finders.find("lizard_riool/sink.png")), "png", 8, 8 ) symbol.allow_overlap = True rule.symbols.append(symbol) style.rules.append(rule) # Add labels. rule = mapnik.Rule() rule.max_scale = 1700 symbol = mapnik.TextSymbolizer( 'code', 'DejaVu Sans Book', 10, mapnik.Color('black') ) symbol.allow_overlap = True symbol.label_placement = mapnik.label_placement.POINT_PLACEMENT symbol.vertical_alignment = mapnik.vertical_alignment.TOP symbol.displacement(0, -5) # slightly above rule.symbols.append(symbol) style.rules.append(rule) # Setup datasource. params = default_database_params() params['table'] = "({}) data".format(manholes.query) datasource = mapnik.PostGIS(**params) # Define layer. layer = mapnik.Layer('manholeLayer') layer.datasource = datasource layer.maxzoom = 35000 layer.styles.append('manholeStyle') layers.append(layer) styles['manholeStyle'] = style
def layer(self, layer_ids=None, request=None): """Return mapnik layers and styles.""" layers = [] styles = {} style = mapnik.Style() styles["riverlineadapterstyle"] = style if self.riverline_result.is_reference: range_method = self._reference_ranges level_field = 'level' else: range_method = self._ranges level_field = 'relative_level' for from_, to_, color in range_method(): rule = mapnik.Rule() if from_ is None: rule.filter = mapnik.Filter("[value] < %s" % to_) elif to_ is None: rule.filter = mapnik.Filter("[value] > %s" % from_) else: rule.filter = mapnik.Filter("[value] > %s and [value] < %s" % (from_, to_)) symbol = mapnik.LineSymbolizer( mapnik.Color(color[0], color[1], color[2]), 3) rule.symbols.append(symbol) style.rules.append(rule) # Catch all rule for unknown states: rule = mapnik.Rule() rule.set_else(True) symbol = mapnik.LineSymbolizer(mapnik.Color(100, 100, 100), 3) rule.symbols.append(symbol) style.rules.append(rule) query = """( select riverline.the_geom, row.%s as value from lizard_rijnmond_riverline riverline, lizard_rijnmond_riverlineresultdata row where riverline.verbose_code = row.location and row.riverline_result_id = %s ) as data""" % (level_field, self.riverline_result_id) logger.info(query) default_database = settings.DATABASES['default'] datasource = mapnik.PostGIS( host=default_database['HOST'], user=default_database['USER'], password=default_database['PASSWORD'], dbname=default_database['NAME'], table=str(query), ) layer = mapnik.Layer("Riverlines", coordinates.RD) layer.datasource = datasource layer.styles.append("riverlineadapterstyle") layers.append(layer) return layers, styles
def render(self, input_file, extent, lyr_style): proj4lyr = '+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs' county_file = '../datas/county.shp' # river_file = '../datas/river.shp' # capital_file ='Capital3.json' filename = os.path.split(input_file)[1] areaCode = os.path.splitext(filename)[0] output_file = input_file.split('.')[0] + '.png' print areaCode # ----------create map--------------------- m = mapnik.Map(extent.xsize, extent.ysize) mapnik.load_map(m, 'cg_config.xml') # ----------create layer 1----------------- layer = mapnik.Layer('dataraster', proj4lyr) # ----------create layer 1 datasource------ layer.datasource = mapnik.Gdal(file=input_file, band=1, nodata=-999) layer.styles.append(lyr_style) # ----------append layer 1 to map---------- m.layers.append(layer) # ----------create layer 2----------------- layer2 = mapnik.Layer('county', proj4lyr) # Create new styles and add the rules. s_county = m.find_style('county') r_county = s_county.rules[0] r_county.filter = mapnik.Filter('[CITY]=' + areaCode) m.append_style(areaCode, s_county) # ----------create layer 2 datasource------ layer2.datasource = mapnik.Shapefile(file=county_file) layer2.styles.append(areaCode) # ----------append layer 2 to map---------- m.layers.append(layer2) # ----------create layer 3----------------- layer3 = mapnik.Layer('capital', proj4lyr) # Create new styles and add the rules. s_capital = m.find_style('capital') r_capital = s_capital.rules[0] r_capital.filter = mapnik.Filter('[CITY]=' + areaCode) m.append_style('symbol', s_capital) # ----------create layer 3 datasource------ layer3.datasource = mapnik.Shapefile(file=county_file) layer3.styles.append('symbol') # ----------append layer 3 to map---------- m.layers.append(layer3) ll = mapnik.Coord(extent.xmax, extent.ymax) tr = mapnik.Coord(extent.xmin, extent.ymin) map_bbox = mapnik.Box2d(tr, ll) # mapnik.Envelope(tr, ll) m.zoom_to_box(map_bbox) print m.envelope(), m.scale() mapnik.render_to_file(m, output_file, 'png') return 'true'
def make_map(self): m = mapnik.Map(self._view.width, self._view.height) m.srs = '+proj=merc +ellps=WGS84 +datum=WGS84 +no_defs' m.background = mapnik.Color(default_colors.water_color) s = mapnik.Style() # style object to hold rules for (name, color) in self._name_to_color.items(): rule = make_rule(color) rule.filter = mapnik.Filter("[%s] = '%s'" % (self._field, name.encode('utf-8'))) s.rules.append(rule) # now add the rule to the style m.append_style('My Style', s) ds = mapnik.GeoJSON(file=self._district_file) layer = mapnik.Layer('world') layer.datasource = ds layer.srs = '+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs' layer.styles.append('My Style') m.layers.append(layer) view = self._view zoom_to_box(m, view.west, view.south, view.east, view.north) return m
def to_mapnik(self, mmap, dirs=None): """ """ prev_cwd = getcwd() if dirs: chdir(dirs.output) try: mmap.srs = self.srs or mmap.srs if self.background: mmap.background = mapnik.Color(str(self.background)) ids = (i for i in xrange(1, 999999)) for layer in self.layers: for style in layer.styles: sty = mapnik.Style() for rule in style.rules: rul = mapnik.Rule('rule %d' % ids.next()) rul.filter = rule.filter and mapnik.Filter(rule.filter.text) or rul.filter rul.min_scale = rule.minscale and rule.minscale.value or rul.min_scale rul.max_scale = rule.maxscale and rule.maxscale.value or rul.max_scale for symbolizer in rule.symbolizers: if not hasattr(symbolizer, 'to_mapnik'): continue sym = symbolizer.to_mapnik() rul.symbols.append(sym) sty.rules.append(rul) mmap.append_style(style.name, sty) lay = mapnik.Layer(layer.name) lay.srs = layer.srs or lay.srs if layer.datasource: lay.datasource = layer.datasource.to_mapnik() lay.minzoom = layer.minzoom or lay.minzoom lay.maxzoom = layer.maxzoom or lay.maxzoom for style in layer.styles: lay.styles.append(style.name) mmap.layers.append(lay) except: # pass it along, but first chdir back to the previous directory # in the finally clause below, to put things back the way they were. raise finally: chdir(prev_cwd)
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')
def add_style_level(self, s, percent): color = "#{}".format(self.c1000_rainbow.colourAt(percent)) width_multiplier = self.get_width_multiplier(self.zoom) # unpaved r = mapnik.Rule() r.filter = mapnik.Filter(self.filter_condition(False, percent)) ls = mapnik.LineSymbolizer() ls.stroke = mapnik.Color(color) ls.stroke_width = 0.1 * width_multiplier r.symbols.append(ls) s.rules.append(r) #paved r = mapnik.Rule() r.filter = mapnik.Filter(self.filter_condition(True, percent)) ls = mapnik.LineSymbolizer() ls.stroke = mapnik.Color(color) ls.stroke_width = 1 * width_multiplier r.symbols.append(ls) s.rules.append(r)
def create_roi_output_style(attr_name): qgis_style_file = os.path.join(os.path.dirname(__file__), "plot_data/roi_pred_classes_4.qml") symbols = {} with open(qgis_style_file, 'rb') as qsf: doc = etree.parse(qsf) for range in doc.xpath('//range'): upper = range.attrib['upper'] lower = range.attrib['lower'] label = range.attrib['label'] symbol = range.attrib['symbol'] symbols[symbol] = { "lower": float(lower), "upper": float(upper), "label": str(label), } for node in doc.xpath("//prop[@k='color']"): layer = node.getparent() sym = layer.getparent() sym_name = sym.attrib['name'] str_color = node.attrib["v"] c = str_color.split(",") symbols[sym_name]["color"] = mapnik.Color( "rgb(%d,%d,%d)" % (int(c[0]), int(c[1]), int(c[2]))) style = mapnik.Style() for sname in symbols: r = mapnik.Rule() psym = mapnik.MarkersSymbolizer() psym.fill = symbols[sname]["color"] psym.width = mapnik.Expression('6') psym.height = mapnik.Expression('6') psym.stroke = mapnik.Stroke(mapnik.Color('white'), 0) r.symbols.append(psym) upper = symbols[sname]["upper"] lower = symbols[sname]["lower"] f = mapnik.Filter("[%s] >= %f and [%s] < %f" % (attr_name, lower, attr_name, upper)) r.filter = f style.opacity = 0.8 style.rules.append(r) return style
def test_filter_init(): m = mapnik.Map(1, 1) mapnik.load_map_from_string(m, map_) filters = [] filters.append(mapnik.Filter("([region]>=0) and ([region]<=50)")) filters.append(mapnik.Filter("(([region]>=0) and ([region]<=50))")) filters.append(mapnik.Filter("((([region]>=0) and ([region]<=50)))")) filters.append(mapnik.Filter('((([region]>=0) and ([region]<=50)))')) filters.append(mapnik.Filter('''((([region]>=0) and ([region]<=50)))''')) filters.append( mapnik.Filter(''' ((([region]>=0) and ([region]<=50))) ''')) filters.append( mapnik.Filter(''' ([region]>=0) and ([region]<=50) ''')) filters.append( mapnik.Filter(''' ([region] >= 0) and ([region] <= 50) ''')) s = m.find_style('s') for r in s.rules: filters.append(r.filter) first = filters[0] for f in filters: eq_(str(first), str(f)) s = m.find_style('s2') eq_(s.filter_mode, mapnik.filter_mode.FIRST)
def UnicodePolyStyle(self, field, feats, colors): if len(feats) != len(colors): print "Error: length of fields and the specified colors should be the same!" polyS = mapnik.Style() for i in range(0, len(feats)): r = mapnik.Rule() r.filter = mapnik.Filter("[" + field + "] = '" + feats[i] + "'") s = mapnik.PolygonSymbolizer(mapnik.Color(colors[i])) r.symbols.append(s) polyS.rules.append(r) r = mapnik.Rule() s = mapnik.LineSymbolizer(mapnik.Color("#000000"), 0.1) r.symbols.append(s) polyS.rules.append(r) return polyS
def make_rules_for_input_combinations(self, possible_values, value_dict={}): """ Recursive function to loop all possible input combinations. For each input combination, calculate rule name and rule. possible_values: dict of fieldname as key and a dict of {value: None} value_dict: dict of all current values (starts empty) Return a dictionary with all rulename as key and rule as value. """ if possible_values: #not all possible values are put into value_dicts fieldname, fieldvalues = possible_values.items()[0] del possible_values[fieldname] rules = {} for fieldvalue in fieldvalues.keys(): new_rules = self.make_rules_for_input_combinations( possible_values, {fieldname: fieldvalue}) rules.update(new_rules) return rules else: #possible values are empty, all values are listed in value_dict rule_name = self.get_rule_name(value_dict) symbol_kwargs = self.get_output_properties(value_dict) symbol_out = symbol_kwargs['symbol'][0] + '.png' size_out_x, size_out_y = symbol_kwargs['size'] filename_abs = str( self.sm.get_symbol_transformed(symbol_out, **symbol_kwargs)) mapnik_rule = mapnik.Rule() ps = mapnik.PointSymbolizer() ps.file = filename_abs mapnik_rule.symbols.append(ps) mapnik_rule.filter = mapnik.Filter( str("[NAME] = '%s'" % (rule_name))) return {rule_name: mapnik_rule}
def _add_rivers(m, colors): s = mapnik.Style() r = mapnik.Rule() r.filter = mapnik.Filter( "[name] = 'Volga' or [name] = 'Dnipro' or [name] = 'Don' or [name] = 'Kama'" ) line_symbolizer = mapnik.LineSymbolizer() line_symbolizer.stroke = mapnik.Color(colors.water_color) line_symbolizer.stroke_width = 0.4 r.symbols.append(line_symbolizer) s.rules.append(r) m.append_style('RiverStyle', s) ds = mapnik.Shapefile( file=SHAPEDIR + 'ne_10m_rivers_lake_centerlines/ne_10m_rivers_lake_centerlines.shp') layer = mapnik.Layer('rivers') layer.datasource = ds layer.srs = '+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs' layer.styles.append('RiverStyle') m.layers.append(layer)
def to_mapnik(self, mmap): """ """ mmap.srs = self.srs or mmap.srs mmap.bgcolor = str(self.bgcolor) or mmap.bgcolor ids = (i for i in xrange(1, 999999)) for layer in self.layers: for style in layer.styles: sty = mapnik.Style() for rule in style.rules: rul = mapnik.Rule('rule %d' % ids.next()) rul.filter = rule.filter and mapnik.Filter( rule.filter.text) or rul.filter rul.min_scale = rule.minscale and rule.minscale.value or rul.min_scale rul.max_scale = rule.maxscale and rule.maxscale.value or rul.max_scale for symbolizer in rule.symbolizers: if not hasattr(symbolizer, 'to_mapnik'): continue sym = symbolizer.to_mapnik() rul.symbols.append(sym) sty.rules.append(rul) mmap.append_style(style.name, sty) lay = mapnik.Layer(layer.name) lay.srs = layer.srs or lay.srs lay.minzoom = layer.minzoom or lay.minzoom lay.maxzoom = layer.maxzoom or lay.maxzoom for style in layer.styles: lay.styles.append(style.name) mmap.layers.append(lay)
def __add_sewers(self, layers, styles): "Add sewer layer and styles." # Get all sewer pipes that constitute to this sewerage. sewers = Sewer.objects.filter(sewerage__pk=self.id) # Define a style. style = mapnik.Style() # QUALITY_UNKNOWN rule = mapnik.Rule() rule.filter = mapnik.Filter( "[quality] = {}".format(Sewer.QUALITY_UNKNOWN) ) rule.max_scale = 1700 symbol = mapnik.TextSymbolizer( 'code', 'DejaVu Sans Book', 10, mapnik.Color('blue') ) symbol.allow_overlap = True # symbol.label_placement = mapnik.label_placement.LINE_PLACEMENT rule.symbols.append(symbol) style.rules.append(rule) # QUALITY_RELIABLE rule = mapnik.Rule() rule.filter = mapnik.Filter( "[quality] = {}".format(Sewer.QUALITY_RELIABLE) ) rule.max_scale = 1700 symbol = mapnik.TextSymbolizer( 'code', 'DejaVu Sans Book', 10, mapnik.Color('green') ) symbol.allow_overlap = True # symbol.label_placement = mapnik.label_placement.LINE_PLACEMENT symbol.allow_overlap = True symbol.opacity = 1.0 rule.symbols.append(symbol) style.rules.append(rule) # QUALITY_UNRELIABLE rule = mapnik.Rule() rule.filter = mapnik.Filter( "[quality] = {}".format(Sewer.QUALITY_UNRELIABLE) ) rule.max_scale = 1700 symbol = mapnik.TextSymbolizer( 'code', 'DejaVu Sans Book', 10, mapnik.Color('red') ) symbol.allow_overlap = True # symbol.label_placement = mapnik.label_placement.LINE_PLACEMENT # symbol.displacement(16, 16) # slightly above rule.symbols.append(symbol) style.rules.append(rule) # Setup datasource. params = default_database_params() params['table'] = "({}) data".format(sewers.query) datasource = mapnik.PostGIS(**params) # Define layer. layer = mapnik.Layer('sewerLayer') layer.datasource = datasource layer.maxzoom = 35000 layer.styles.append('sewerStyle') layers.append(layer) styles['sewerStyle'] = style
def __add_measurements(self, layers, styles): "Docstring." measurements = SewerMeasurement.objects.filter( sewer__sewerage__pk=self.id ) style = mapnik.Style() for _, _, min_pct, max_pct, color in CLASSES: r, g, b, a = html_to_mapnik(color) icon = SYMBOL_MANAGER.get_symbol_transformed( RIOOL_ICON, color=(r, g, b, a) ) rule = mapnik.Rule() rule.filter = mapnik.Filter( str("[flooded_pct] >= %s and [flooded_pct] < %s" % (min_pct, max_pct)) ) symbol = mapnik.PointSymbolizer( os.path.join(GENERATED_ICONS, icon), "png", 16, 16 ) symbol.allow_overlap = True rule.symbols.append(symbol) style.rules.append(rule) # Style else rule. r, g, b, a = html_to_mapnik('00000') icon = SYMBOL_MANAGER.get_symbol_transformed( RIOOL_ICON, color=(r, g, b, a) ) rule = mapnik.Rule() rule.set_else(True) symbol = mapnik.PointSymbolizer( os.path.join(GENERATED_ICONS, icon), "png", 16, 16 ) symbol.allow_overlap = True rule.symbols.append(symbol) style.rules.append(rule) # Setup datasource. params = default_database_params() params['table'] = "({}) data".format(measurements.query) datasource = mapnik.PostGIS(**params) params = default_database_params() # Define layer. layer = mapnik.Layer('measurementLayer') layer.datasource = datasource layer.maxzoom = 35000 layer.styles.append('measurementStyle') layers.append(layer) styles['measurementStyle'] = style
layer = mapnik.Layer("unused_roads") layer.datasource = mapnik.PostGIS(host='localhost', user='******', password='', dbname='gps_heatmap', table='road_segments') layer.styles.append("unused_road_style") map.layers.append(layer) # Set up our unused road layer style. line_symbol = mapnik.LineSymbolizer(mapnik.Color("#c0c0c0"), 1.0) rule = mapnik.Rule() rule.filter = mapnik.Filter("[tally] = 0") rule.symbols.append(line_symbol) style = mapnik.Style() style.rules.append(rule) map.append_style("unused_road_style", style) # Define our used road layer. layer = mapnik.Layer("used_roads") layer.datasource = mapnik.PostGIS(host='localhost', user='******', password='', dbname='gps_heatmap', table='road_segments') layer.styles.append("used_road_style")
#!/usr/bin/env python import mapnik precinct_style = mapnik.Style() roads_style = mapnik.Style() for roads in range(1, 884): the_filter = '[OBJECTID] = {0}'.format(roads) rule = mapnik.Rule() rule.filter = mapnik.Filter(the_filter) 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) layer = mapnik.Layer("Roads Layer") layer.datasource = mapnik.Shapefile(file="data/Roads.shp") layer.styles.append("Roads Style") map1 = mapnik.Map(1024, 1024) map1.background = mapnik.Color("#EEEEEE") map1.append_style("Roads Style", roads_style) map1.layers.append(layer) map1.zoom_all()
def generateMap(tableName, minX, minY, maxX, maxY, mapWidth, mapHeight, hiliteExpr=None, points=None): extent = "{},{},{},{}".format(minX, minY, maxX, maxY) layer = mapnik.Layer("Layer") layer.datasource = mapnik.PostGIS(dbname="distal", table=tableName, user="******", password="******", extent=extent, geometry_field="outline", srid=4326) map = mapnik.Map(mapWidth, mapHeight, '+proj=longlat +datum=WGS84') map.background = mapnik.Color("#8080a0") style = mapnik.Style() rule = mapnik.Rule() if hiliteExpr != None: rule.filter = mapnik.Filter(hiliteExpr) rule.symbols.append(mapnik.PolygonSymbolizer(mapnik.Color("#408000"))) rule.symbols.append( mapnik.LineSymbolizer(mapnik.Stroke(mapnik.Color("#000000"), 0.1))) style.rules.append(rule) rule = mapnik.Rule() rule.set_else(True) rule.symbols.append(mapnik.PolygonSymbolizer(mapnik.Color("#a0a0a0"))) rule.symbols.append( mapnik.LineSymbolizer(mapnik.Stroke(mapnik.Color("#404040"), 0.1))) style.rules.append(rule) map.append_style("Map Style", style) layer.styles.append("Map Style") map.layers.append(layer) if points != None: memoryDatasource = mapnik.MemoryDatasource() context = mapnik.Context() context.push("name") next_id = 1 for long, lat, name in points: wkt = "POINT (%0.8f %0.8f)" % (long, lat) feature = mapnik.Feature(context, next_id) feature['name'] = name feature.add_geometries_from_wkt(wkt) next_id = next_id + 1 memoryDatasource.add_feature(feature) layer = mapnik.Layer("Points") layer.datasource = memoryDatasource style = mapnik.Style() rule = mapnik.Rule() pointImgFile = os.path.join(os.path.dirname(__file__), "point.png") shield = mapnik.ShieldSymbolizer(mapnik.Expression('[name]'), "DejaVu Sans Bold", 10, mapnik.Color("#000000"), mapnik.PathExpression(pointImgFile)) shield.displacement = (0, 7) shield.unlock_image = True rule.symbols.append(shield) style.rules.append(rule) map.append_style("Point Style", style) layer.styles.append("Point Style") map.layers.append(layer) map.zoom_to_box(mapnik.Envelope(minX, minY, maxX, maxY)) scriptDir = os.path.dirname(__file__) cacheDir = os.path.join(scriptDir, "..", "mapCache") if not os.path.exists(cacheDir): os.mkdir(cacheDir) fd, filename = tempfile.mkstemp(".png", dir=cacheDir) os.close(fd) mapnik.render_to_file(map, filename, "png") return "../mapCache/" + os.path.basename(filename)
timeStart = time.time() m = mapnik.Map(256, 256) m.background = mapnik.Color('white') shpLayer = mapnik.Layer('SHP') shpLayer.datasource = mapnik.Shapefile( file=r"D:\LIJUNGANG\work\MapServer\mapnik_data\dltb_clip.shp") lineLayer = mapnik.Layer('Line') lineLayer.datasource = mapnik.Shapefile( file=r"D:\LIJUNGANG\work\MapServer\mapnik_data\xzdm_clip.shp") shpStyle = mapnik.Style() shpStyle.filter_mode = mapnik.filter_mode.FIRST #forestRule=mapnik.Rule() farmlandRule011 = mapnik.Rule() filter011 = mapnik.Filter("[DLBM]='011'") farmlandRule011.filter = filter011 farmlandRule011.symbols.append( mapnik.PolygonSymbolizer(mapnik.Color("rgb(255,255,100)"))) shpStyle.rules.append(farmlandRule011) farmlandRule012 = mapnik.Rule() filter012 = mapnik.Filter("[DLBM]='012'") farmlandRule012.filter = filter012 farmlandRule012.symbols.append( mapnik.PolygonSymbolizer(mapnik.Color("rgb(255,255,150)"))) shpStyle.rules.append(farmlandRule012) farmlandRule013 = mapnik.Rule() filter013 = mapnik.Filter("[DLBM]='013'") farmlandRule013.filter = filter013
def main(): """ Our main program. """ # Open up each layer's data source, remember the projection, and calculate # the overall boundary for all the displayed data that matches our bounds # filter. projections = [] minLong = None maxLong = None minLat = None maxLat = None try: boundsFilter = BOUNDS_FILTER except NameError: boundsFilter = {} for i in range(len(LAYERS)): src = LAYERS[i] print "Processing " + src['sourceFile'] + "..." shapefile = osgeo.ogr.Open(src['sourceFile']) layer = shapefile.GetLayer(0) spatialRef = layer.GetSpatialRef() if spatialRef != None: projection = spatialRef.ExportToProj4() else: if len(projections) > 0: projection = projections[0] else: spatialRef = osgeo.osr.SpatialReference() spatialRef.SetWellKnownGeogCS('WGS84') projection = spatialRef.ExportToProj4() for i in range(layer.GetFeatureCount()): feature = layer.GetFeature(i) matches = True for key, value in boundsFilter.items(): if feature.GetField(key) != value: matches = False break if not matches: continue if src.get("printAttrs") == True: print " " + repr(feature.items().items()) bounds = feature.GetGeometryRef().GetEnvelope() if minLong == None: minLong, maxLong, minLat, maxLat = bounds else: if bounds[0] < minLong: minLong = bounds[0] if bounds[1] > maxLong: maxLong = bounds[1] if bounds[2] < minLat: minLat = bounds[2] if bounds[3] > maxLat: maxLat = bounds[3] projections.append(projection) # Adjust the calculated bounds by the bounds margin, if any. try: minLong = minLong - BOUNDS_MARGIN maxLong = maxLong + BOUNDS_MARGIN minLat = minLat - BOUNDS_MARGIN maxLat = maxLat + BOUNDS_MARGIN except NameError: pass # If we've been asked to do so, print out the calculated bounds. try: if PRINT_BOUNDS: print "MIN_LAT = %0.4f" % minLat print "MAX_LAT = %0.4f" % maxLat print "MIN_LONG = %0.4f" % minLong print "MAX_LONG = %0.4f" % maxLong except NameError: pass # Calculate the size of the map image, based on the calculated boundaries. if OVERRIDE_MIN_LAT != None: minLat = OVERRIDE_MIN_LAT if OVERRIDE_MAX_LAT != None: maxLat = OVERRIDE_MAX_LAT if OVERRIDE_MIN_LONG != None: minLong = OVERRIDE_MIN_LONG if OVERRIDE_MAX_LONG != None: maxLong = OVERRIDE_MAX_LONG mapBounds = mapnik.Envelope(minLong, minLat, maxLong, maxLat) aspectRatio = mapBounds.width() / mapBounds.height() mapWidth = MAX_WIDTH mapHeight = int(mapWidth / aspectRatio) if mapHeight > MAX_HEIGHT: # Scale the map to fit. scaleFactor = float(MAX_HEIGHT) / float(mapHeight) mapWidth = int(mapWidth * scaleFactor) mapHeight = int(mapHeight * scaleFactor) # Create our map. m = mapnik.Map(mapWidth, mapHeight, projections[0]) m.background = mapnik.Color(BACKGROUND_COLOR) # Setup the stylesheets to show the contents of each shapefile. for i in range(len(LAYERS)): src = LAYERS[i] s = mapnik.Style() r = mapnik.Rule() if src.get("filter") != None: r.filter = mapnik.Filter(src['filter']) if src['fillColor'] != None: ps = mapnik.PolygonSymbolizer(mapnik.Color(src['fillColor'])) r.symbols.append(ps) if src['lineColor'] != None: stroke = mapnik.Stroke(mapnik.Color(src['lineColor']), src['lineWidth']) if src.get("lineJoin") == "miter": stroke.line_join = mapnik.line_join.MITER_JOIN elif src.get("lineJoin") == "round": stroke.line_join = mapnik.line_join.ROUND_JOIN elif src.get("linJoin") == "bevel": stroke.line_join = mapnik.line_join.BEVEL_JOIN if src.get("lineCap") == "round": stroke.line_cap = mapnik.line_cap.ROUND_CAP elif src.get("lineCap") == "square": stroke.line_cap = mapnik.line_cap.SQUARE_CAP elif src.get("lineCap") == "butt": stroke.line_cap = mapnik.line_cap.BUTT_CAP if src.get("lineDash") != None: stroke.add_dash(src['lineDash'], src['lineDash'] * 2) ls = mapnik.LineSymbolizer(stroke) r.symbols.append(ls) if src['labelField'] != None: ts = mapnik.TextSymbolizer( mapnik.Expression("[" + src['labelField'] + "]"), "DejaVu Sans Bold", src['labelSize'], mapnik.Color(src['labelColor'])) if src.get("labelHalo") != None: ts.halo_radius = src['labelHalo'] if src.get("labelPlacement") == "line": ts.label_placement = mapnik.label_placement.LINE_PLACEMENT if src.get("labelAllowOverlap") != None: ts.allow_overlap = src['labelAllowOverlap'] else: ts.allow_overlap = True r.symbols.append(ts) s.rules.append(r) m.append_style("style-" + str(i + 1), s) # Setup our various map layers. for i in range(len(LAYERS)): src = LAYERS[i] l = mapnik.Layer("layer-" + str(i + 1), projections[i]) if src['sourceFile'].endswith(".shp"): l.datasource = mapnik.Shapefile(file=src['sourceFile']) else: l.datasource = mapnik.Ogr(file=src['sourceFile'], layer=src.get("layer")) l.styles.append("style-" + str(i + 1)) m.layers.append(l) # Finally, render the map. m.zoom_to_box(mapBounds) mapnik.render_to_file(m, "map.png", "png") os.system("open map.png")
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')
def tileMapConfig(map_id): map_selected = BasquiMap.objects.get(pk=map_id) layersMapOptions = LayerMapOptions.objects.filter( basqui_map=map_selected).order_by('-position') layers_used = Shapefile.objects.filter( Q(layermapoptions__basqui_map=map_selected), Q(layermapoptions__style_visible=True) | Q(layermapoptions__label_visible=True)) mapXML = mapnik.Map( TILE_WIDTH, TILE_HEIGHT, "+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0.0 +k=1.0 +units=m +nadgrids=@null +no_defs +over" ) mapXML.buffer_size = 128 if len(layers_used) > 0: query = """(SELECT shapefile_id, coalesce(geom_multipoint, geom_multilinestring, geom_multipolygon) as g %s FROM layers_feature WHERE shapefile_id IN (%s) AND (geom_multipoint && !bbox! OR geom_multilinestring && !bbox! OR geom_multipolygon && !bbox! ) ) as geom""" % (''.join([ ",attribute_value->'" + label.field.name + "' as " + str(label.field.name).lower() + "_" + str(label.pk) for x in layersMapOptions.filter(label_visible=True) for label in x.layerlabel_set.all() ]).replace(',None', ''), ','.join([str(x.pk) for x in layers_used])) #','.join(["attribute_value->'" + x.label.field.name +"'" if x.label is not None else 'None' for x in layersMapOptions ]).replace(',None',''), datasource = mapnik.PostGIS( host=dbSettings['HOST'], user=dbSettings['USER'], password=dbSettings['PASSWORD'], dbname=dbSettings['NAME'], port=dbSettings['PORT'], table=query, geometry_field='g', #extent_from_subquery=True, estimate_extent=False, srid=3857, extent='-20037508.34, -20037508.34, 20037508.34, 20037508.34', simplify_geometries=True, geometry_table='layers_feature') featureLayer = mapnik.Layer("tiled_layer") featureLayer.srs = "+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0.0 +k=1.0 +units=m +nadgrids=@null +no_defs +over" featureLayer.datasource = datasource featureLayer.cache_features = True #defining the feature layer styles for layerMapOptions in layersMapOptions.filter(style_visible=True): layerStyles = layerMapOptions.layerstyle_set.all().order_by( '-position') layer = layerMapOptions.layer featureLayer.styles.append( str(layer.name) + '_Styles_' + str(layerMapOptions.pk)) layer_style = mapnik.Style() for layerStyle in layerStyles: style_rule = mapnik.Rule() if layerStyle.filter: style_rule.filter = mapnik.Filter( "[shapefile_id] = %s and (%s)" % (layer.pk, str(layerStyle.filter))) else: style_rule.filter = mapnik.Filter("[shapefile_id] = %s" % layer.pk) if layerStyle.minScale: style_rule.min_scale = layerStyle.minScale if layerStyle.maxScale: style_rule.max_scale = layerStyle.maxScale if layer.geom_type in ["Point", "MultiPoint"]: m = mapnik.MarkersSymbolizer() m.filename = os.path.abspath("../media/%s" % layerStyle.marker.svg) m.fill = mapnik.Color(str(layerStyle.fill)) m.fill_opacity = layerStyle.fill_opacity s = mapnik.Stroke() s.color = mapnik.Color(str(layerStyle.stroke_color)) s.width = layerStyle.stroke_width s.opacity = layerStyle.stroke_opacity m.stroke = s if layerStyle.transform: m.transform = str(layerStyle.transform) m.allow_overlap = layerStyle.allow_overlap m.spacing = layerStyle.spacing m.max_error = layerStyle.max_error #m.placement = mapnik.marker_placement(layerStyle.placement) #m.ignore_placement = layerStyle.ignore_placement style_rule.symbols.append(m) elif layer.geom_type in ["LineString", "MultiLineString"]: l = mapnik.LineSymbolizer() l.stroke.color = mapnik.Color(str(layerStyle.stroke_color)) l.stroke.width = layerStyle.stroke_width l.stroke.opacity = layerStyle.stroke_opacity l.stroke.line_join = mapnik.line_join( layerStyle.stroke_linejoin) l.stroke.line_cap = mapnik.line_cap( layerStyle.stroke_linecap) if layerStyle.dash_array: dash_array = [ tuple(float(i) for i in el.strip('()').split(',')) for el in layerStyle.dash_array.split('),(') ] for d in dash_array: l.stroke.add_dash(d[0], d[1]) l.stroke.gamma = layerStyle.gamma l.stroke.gamma_method = mapnik.gamma_method( layerStyle.gamma_method) l.smooth = layerStyle.smooth l.simplify_tolerance = layerStyle.simplify_tolerance l.offset = layerStyle.stroke_offset l.clip = layerStyle.clip l.rasterizer = mapnik.line_rasterizer( layerStyle.stroke_rasterizer) style_rule.symbols.append(l) elif layer.geom_type in ["Polygon", "MultiPolygon"]: p = mapnik.PolygonSymbolizer() p.fill = mapnik.Color(str(layerStyle.fill)) p.fill_opacity = layerStyle.fill_opacity p.clip = layerStyle.clip p.gamma = layerStyle.gamma p.gamme_method = mapnik.gamma_method( layerStyle.gamma_method) p.smooth = layerStyle.smooth p.simplify_tolerance = layerStyle.simplify_tolerance l = mapnik.LineSymbolizer() l.stroke.color = mapnik.Color(str(layerStyle.stroke_color)) l.stroke.opacity = layerStyle.stroke_opacity l.stroke.width = layerStyle.stroke_width if layerStyle.dash_array: dash_array = [ tuple(float(i) for i in el.strip('()').split(',')) for el in layerStyle.dash_array.split('),(') ] for d in dash_array: l.stroke.add_dash(d[0], d[1]) l.offset = layerStyle.stroke_offset l.clip = layerStyle.clip l.stroke.gamma = layerStyle.gamma l.smooth = layerStyle.smooth l.simplify_tolerance = layerStyle.simplify_tolerance style_rule.symbols.append(p) style_rule.symbols.append(l) layer_style.rules.append(style_rule) mapXML.append_style( str(layer.name) + '_Styles_' + str(layerMapOptions.pk), layer_style) #defining label styles for layerMapOptions in layersMapOptions.filter(label_visible=True): layerLabels = layerMapOptions.layerlabel_set.all().order_by( '-position') layer = layerMapOptions.layer featureLayer.styles.append( str(layer.name) + '_Label_' + str(layerMapOptions.pk)) label_style = mapnik.Style() for layerLabel in layerLabels: label_rule = mapnik.Rule() if layerLabel.filter: label_rule.filter = mapnik.Filter( "[shapefile_id] = %s and (%s)" % (layer.pk, str(layerLabel.filter))) else: label_rule.filter = mapnik.Filter("[shapefile_id] = %s" % layer.pk) if layerLabel.minScale: label_rule.min_scale = layerLabel.minScale if layerLabel.maxScale: label_rule.max_scale = layerLabel.maxScale label_column = '[%s_%s]' % (str( layerLabel.field).lower(), str(layerLabel.pk)) t = mapnik.TextSymbolizer(mapnik.Expression(label_column), str(layerLabel.face_name), layerLabel.size, mapnik.Color(str(layerLabel.fill))) t.halo_fill = mapnik.Color(str(layerLabel.halo_fill)) t.halo_radius = layerLabel.halo_radius t.halo_rasterizer = mapnik.halo_rasterizer( layerLabel.halo_rasterizer) t.opacity = layerLabel.opacity t.character_spacing = layerLabel.character_spacing t.line_spacing = layerLabel.line_spacing t.text_ratio = layerLabel.text_ratio t.text_transform = mapnik.text_transform( layerLabel.text_transform) t.clip = layerLabel.clip t.label_placement = mapnik.label_placement( layerLabel.label_placement) t.vertical_alignment = mapnik.vertical_alignment( layerLabel.vertical_alignment) t.horizontal_alignment = mapnik.horizontal_alignment( layerLabel.horizontal_alignment) t.justify_alignment = mapnik.justify_alignment( layerLabel.justify_alignment) t.displacement = (layerLabel.dx, layerLabel.dy) t.orientation = mapnik.Expression(str(layerLabel.orientation)) t.rotate_displacement = layerLabel.rotate_displacement t.label_position_tolerance = layerLabel.label_position_tolerance t.avoid_edges = layerLabel.avoid_edges t.minimum_padding = layerLabel.minimum_padding t.allow_overlap = layerLabel.allow_overlap t.minimum_distance = layerLabel.minimum_distance t.repeat_distance = mapnik.Expression( str(layerLabel.repeat_distance)) t.minimum_path_length = layerLabel.minimum_path_length t.maximum_angle_char_delta = layerLabel.maximum_angle_char_delta t.wrap_width = layerLabel.wrap_width if layerLabel.wrap_character: t.wrap_character = ord(layerLabel.wrap_character) t.wrap_before = layerLabel.wrap_before label_rule.symbols.append(t) label_style.rules.append(label_rule) mapXML.append_style( str(layer.name) + '_Label_' + str(layerMapOptions.pk), label_style) mapXML.layers.append(featureLayer) #saving the map mapnik xml mapnik_xml_path = "../tilestache/%s/maps/viewer/%s_%s.xml" % (str( map_selected.created_by.username), str( map_selected.name), str(map_selected.pk)) mapnik.save_map(mapXML, mapnik_xml_path)
#!/usr/bin/env python import mapnik precinct_style = mapnik.Style() roads_style = mapnik.Style() for precinct in range(1, 53): 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)
def draw_district_outline(statefp, state, district, shpfeature, map_size, contextmap) : # Create an image with district outlines and shading over the parts of the map # in other districts or other states. Also compute our desired bounding box. # Get bounding box of this map, which will be a little larger than the boudning box of the district. long_min, long_max, lat_min, lat_max = shpfeature.GetGeometryRef().GetEnvelope() margin = 0.06 if contextmap : margin = 1.5 d_long = long_max-long_min d_lat = lat_max-lat_min long_min -= d_long*margin long_max += d_long*margin lat_min -= d_lat*margin lat_max += d_lat*margin # Choose an aspect ratio for the final image that is a good match for # the shape of the district. We have two choices. We could use nice-looking # aspect ratios or we could use aspect ratios that match common sizes of # paper so that the map can be printed nicely. good_aspect_ratios = [ (3.0, 3.0/1.0), # 8.5x17 tabloid landscape (1.5, 16.0/9.0), # HD widescreen (1.25, 11.0/8.5), # 8.5x11 letter landscape (1/1.25, 1.0/1.0), # square (1/1.5, 8.5/11.0), # 8.5x11 letter portrait (0, 8.5/17.0), # 8.5x17 tabloid portrait ] for threshold, ratio in good_aspect_ratios: if d_long/d_lat > threshold: if ratio > 1.0: map_width = int(ratio * map_size) map_height = map_size else: map_width = map_size map_height = int(map_size / ratio) break # Create a map. m = mapnik.Map(map_width, map_height, output_projection) # Center to the projected coordinates. bounds = (mapnik.Projection(output_projection).forward( mapnik.Projection(census_shapefile_projection).inverse(mapnik.Coord(long_min, lat_min)) ), mapnik.Projection(output_projection).forward( mapnik.Projection(census_shapefile_projection).inverse(mapnik.Coord(long_max, lat_max)) )) m.zoom_to_box(mapnik.Envelope(bounds[0].x, bounds[0].y, bounds[1].x, bounds[1].y)) if not contextmap : # Add a layer for counties and ZCTAs. # TODO: These should really be generated with the map tile layer # so that the labels don't hit each other. for layer, featurename, labelfontsize, labelcolor, border in ( ("county", "NAME", map_size/40, mapnik.Color('rgb(70%,20%,20%)'), True), ("zcta510", "ZCTA5CE10", map_size/60, mapnik.Color('rgb(40%,40%,80%)'), False), ): s = mapnik.Style() r = mapnik.Rule() if border: p = mapnik.LineSymbolizer(labelcolor, map_size/300) p.stroke.opacity = .3 p.stroke.add_dash(.1, .1) r.symbols.append(p) r.symbols.append(mapnik.TextSymbolizer(mapnik.Expression('[%s]' % featurename), mapnik_label_font, labelfontsize, labelcolor)) s.rules.append(r) m.append_style('%s Style' % layer, s) lyr = mapnik.Layer('world', census_shapefile_projection) lyr.datasource = mapnik.Shapefile(file=sys.argv[1] + "/tl_2013_us_%s.shp" % layer) lyr.styles.append('%s Style' % layer) m.layers.append(lyr) # Draw shading and numbering for the other districts. district_outline_color = mapnik.Color('rgb(100%,75%,25%)') s = mapnik.Style() r = mapnik.Rule() p = mapnik.PolygonSymbolizer(mapnik.Color('rgb(70%,70%,70%)')) p.fill_opacity = .55 r.symbols.append(p) r.filter = mapnik.Filter("([CD113FP] <> '" + district + "' || [STATEFP] <> '" + statefp + "') && [CD113FP] != 'ZZ'") t = mapnik.TextSymbolizer(mapnik.Expression('[CD113FP]'), mapnik_label_font, map_size/15, district_outline_color) t.halo_radius = map_size/120 r.symbols.append(t) s.rules.append(r) # Draw the outlines of districts. Use a hard thin outline to be exact plus # a faded wider outline for strength. r = mapnik.Rule() p = mapnik.LineSymbolizer(district_outline_color, 2) r.symbols.append(p) p = mapnik.LineSymbolizer(district_outline_color, map_size/140) p.stroke.opacity = .35 r.symbols.append(p) s.rules.append(r) m.append_style('Other Districts Style',s) lyr = mapnik.Layer('world', census_shapefile_projection) lyr.datasource = mapnik.Shapefile(file=sys.argv[1] + "/tl_2013_us_cd113.shp") lyr.styles.append('Other Districts Style') m.layers.append(lyr) im = mapnik.Image(map_width, map_height) mapnik.render(m, im) env = m.envelope() env = ( mapnik.Projection(output_projection).inverse(mapnik.Coord(env[0], env[1])), mapnik.Projection(output_projection).inverse(mapnik.Coord(env[2], env[3])) ) return im, env
#!/usr/bin/env python import os import mapnik # create basemap m = mapnik.Map(800, 600) mapnik.load_map(m, 'population.xml') # grab the countries layer countries = m.layers[0] ds = countries.datasource countries.styles.append('selected') featureset = ds.all_features() criteria = mapnik.Filter("[POP2005] > 100000000") # get features that pass criteria queryset = [f for f in featureset if criteria.passes(f)] for feature in queryset: m.zoom_to_box(feature.envelope()) m.zoom(1.05) name = str(feature.attributes['NAME']) print 'Matched %s...' % name feature_filter = mapnik.Filter("[NAME] = '%s'" % name) # selected/highlighted style s, r = mapnik.Style(), mapnik.Rule() r.symbols.append(mapnik.LineSymbolizer(mapnik.Color('darkorange'), 3)) r.symbols.append(mapnik.LineSymbolizer(mapnik.Color('yellow'), 2)) t = mapnik.TextSymbolizer('NAME', 'DejaVu Sans Book', 30,
import mapnik MIN_LAT = -35 MAX_LAT = +35 MIN_LONG = -12 MAX_LONG = +50 MAP_WIDTH = 700 MAP_HEIGHT = 800 # Define our polygon styles: polygonStyle = mapnik.Style() rule = mapnik.Rule() rule.filter = mapnik.Filter("[NAME] = 'Angola'") symbol = mapnik.PolygonSymbolizer(mapnik.Color("#604040")) rule.symbols.append(symbol) polygonStyle.rules.append(rule) rule = mapnik.Rule() rule.filter = mapnik.Filter("[NAME] != 'Angola'") symbol = mapnik.PolygonSymbolizer(mapnik.Color("#406040")) rule.symbols.append(symbol) polygonStyle.rules.append(rule) rule = mapnik.Rule() symbol = mapnik.LineSymbolizer(mapnik.Color("#000000"), 0.1) rule.symbols.append(symbol)
blue = mapnik.PointSymbolizer('b.png', 'png', 50, 50) blue.allow_overlap = True # create point symbolizer for yellow icons yellow = mapnik.PointSymbolizer('y.png', 'png', 50, 50) yellow.allow_overlap = True s = mapnik.Style() r = mapnik.Rule() r.symbols.append(text) s.rules.append(r) s2 = mapnik.Style() r2 = mapnik.Rule() r2.symbols.append(blue) r2.filter = mapnik.Filter("[Name] = 'blue!'") s2.rules.append(r2) r3 = mapnik.Rule() r3.symbols.append(yellow) r3.filter = mapnik.Filter("[Name] = 'yellow!'") s2.rules.append(r3) icons = mapnik.Layer('Memory Datasource') icons.datasource = pds icons.styles.append('Point Style') m.layers.append(icons) labels = mapnik.Layer('Memory Datasource') labels.datasource = pds labels.styles.append('Label Style')