def serialize(xml, options):
    try:
        try:
            import mapnik2 as mapnik
        except ImportError:
            import mapnik
    except ImportError:
        sys.exit(color_text(1, "Error: saving xml requires Mapnik python bindings to be installed"))
    m = mapnik.Map(1, 1)
    if options.from_string:
        mapnik.load_map_from_string(m, xml, True)
    else:
        mapnik.load_map(m, xml, True)
    if options.output:
        mapnik.save_map(m, options.output)
    else:
        if hasattr(mapnik, "mapnik_version") and mapnik.mapnik_version() >= 700:
            print mapnik.save_map_to_string(m)
        else:
            sys.exit(
                color_text(
                    1,
                    "Minor error: printing XML to stdout requires Mapnik >=0.7.0, please provide a second argument to save the output to a file",
                )
            )
def test_load_save_map():
    map = mapnik2.Map(256,256)
    in_map = "../data/good_maps/raster_symbolizer.xml"
    mapnik2.load_map(map, in_map)

    out_map = mapnik2.save_map_to_string(map)
    assert 'RasterSymbolizer' in out_map
    assert 'RasterColorizer' in out_map
    assert 'stop' in out_map
def main(root,**options):
    m = mapnik.Map(1,1)

    datasource = options.get('datasource')
    if datasource and datasource.endswith('shp'):
        shp_dir = os.path.abspath(datasource).split('.shp')[0]
        name = datasource.split('.shp')[0]
        datasource = mapnik.Shapefile(file=shp_dir)
        if srid is not None:
            m.srs = '+init=epsg:%s' % srid
        else:
            srs = proj4_from_osr(shp_dir)
            if srs:
                m.srs = srs
    
    
    layers = []
    if hasattr(root,'NamedLayer'):
        layers.extend(root.NamedLayer)
    if hasattr(root,'UserLayer'):
        layers.extend(root.UserLayer)
    for layer in layers:
        m_layer, styles = ogc_layer_to_mapnik(layer)
        for (name, style) in styles:
            m.append_style(name, style)
        if datasource:
            m_layer.datasource = datasource
        m_layer.srs = m.srs
        m.layers.append(m_layer)

    if FIX_HEX:
        (handle, path) = tempfile.mkstemp(suffix='.xml', prefix='geotools2mapnik-')
        os.close(handle)
        open(path,'w').write(mapnik.save_map_to_string(m))
        tree = objectify.parse(path)
        fix_colors(tree)
        print etree.tostring(tree)#,pretty_print=True)
    else:
        print mapnik.save_map_to_string(m)
Beispiel #4
0
    def stream(self):
        self.initialize()
        for kml_reference in self.kmls:
            self.m('handling %s' % kml_reference)
            kml, tree = self.parse(kml_reference)
            self.m('found kml: %s' % kml)
            root = tree.getroot()
            #self.ogr_ds = ogr.Open(kml)
            #if not self.ogr_ds and not self.has_network_links:
                #sys.exit('Sorry this KML is not a valid datasource, there are no layers!')
            
            kml_name = self.kml_unique_name(kml)

            self.collect_layer_style_maps(kml,tree)

            features = self.get_features(root)

            #self.collect_feature_styles(kml_name,features)
            
            # make sense of stylemapping first
            #if hasattr(root,'Document') and hasattr(root.Document,'StyleMap'):
            style_maps,styles = self.get_all_style_data(tree,root)
            self.collect_style_maps(kml_name,style_maps)
            self.collect_styles(kml,kml_name,styles)
            
            # then collect actual styles
            #if hasattr(root,'Document') and hasattr(root.Document,'Style'):
            #    self.collect_styles(kml,kml_name,root.Document.Style)

            # match stylesmaps to styles
            #if self.style_maps.get(kml_name):
            #    if not self.style_maps[kml_name].get(sty_name): # if not hover...
            #        pass#break

            self.handle_layers(kml,kml_name,features)
            
        if not self.quiet:
            print mapnik.save_map_to_string(self.map)
def test_load_save_map():
    map = mapnik2.Map(256,256)
    in_map = "../data/good_maps/raster_symbolizer.xml"
    try:
        mapnik2.load_map(map, in_map)
    
        out_map = mapnik2.save_map_to_string(map)
        assert 'RasterSymbolizer' in out_map
        assert 'RasterColorizer' in out_map
        assert 'stop' in out_map
    except RuntimeError, e:
        # only test datasources that we have installed
        if not 'Could not create datasource' in str(e):
            raise RuntimeError(str(e))
def test_load_save_load_map():
    map = mapnik2.Map(256,256)
    in_map = "../data/good_maps/glyph_symbolizer.xml"
    mapnik2.load_map(map, in_map)
    style = map.find_style('arrows')
    sym = style.rules[0].symbols[0]
    assert isinstance(sym, mapnik2.GlyphSymbolizer)
    assert sym.angle_mode == mapnik2.angle_mode.AZIMUTH

    out_map = mapnik2.save_map_to_string(map).decode('utf8')
    map = mapnik2.Map(256,256)
    mapnik2.load_map_from_string(map, out_map.encode('utf8'))
    assert 'GlyphSymbolizer' in out_map
    # make sure non-ascii characters are well supported since most interesting
    # glyphs for symbology are usually in that range
    assert u'í' in out_map, out_map
Beispiel #7
0
    def view_xml(self, m=None):
        if not self.dock_window:
            self.dock_window = TextEditor(self)
            self.iface.mainWindow().addDockWidget(Qt.BottomDockWidgetArea, self.dock_window)
            if not self.using_mapnik:
                # http://trac.osgeo.org/qgis/changeset/12955 - render starting signal
                QObject.connect(self.canvas, SIGNAL("renderComplete(QPainter *)"), self.checkLayers)

        self.dock_window.show()
        if self.loaded_mapfile:
            # if we have loaded a map xml or mml
            # so lets just display the active file
            xml = open(self.loaded_mapfile, "rb").read()
        else:
            if not m:
                # regenerate from qgis objects
                e_c = sync.EasyCanvas(self, self.canvas)
                m = e_c.to_mapnik()
            if hasattr(mapnik, "save_map_to_string"):
                xml = mapnik.save_map_to_string(m)
            else:
                (handle, mapfile) = tempfile.mkstemp(".xml", "quantumnik-map-")
                os.close(handle)
                mapnik.save_map(m, str(mapfile))
                xml = open(mapfile, "rb").read()
        e = self.canvas.extent()
        bbox = "%s %s %s %s" % (e.xMinimum(), e.yMinimum(), e.xMaximum(), e.yMaximum())
        cmd = "\n<!-- nik2img.py mapnik.xml out.png -d %s %s -e %s -->\n" % (
            self.canvas.width(),
            self.canvas.height(),
            bbox,
        )
        try:
            if self.mapnik_map:
                cmd += "<!-- <MinScaleDenominator>%s</MinScaleDenominator> -->\n" % (
                    self.mapnik_map.scale_denominator()
                )
        except:
            pass

        code = xml + cmd
        if HIGHLIGHTING:
            highlighted = highlight(code, XmlLexer(), HtmlFormatter(linenos=False, nowrap=False, full=True))
            self.dock_window.textEdit.setHtml(highlighted)
        else:
            self.dock_window.textEdit.setText(xml + cmd)
def test_load_save_load_map():
    map = mapnik2.Map(256,256)
    in_map = "../data/good_maps/glyph_symbolizer.xml"
    try:
        mapnik2.load_map(map, in_map)
        style = map.find_style('arrows')
        sym = style.rules[0].symbols[0]
        assert isinstance(sym, mapnik2.GlyphSymbolizer)
        assert sym.angle_mode == mapnik2.angle_mode.AZIMUTH
    
        out_map = mapnik2.save_map_to_string(map).decode('utf8')
        map = mapnik2.Map(256,256)
        mapnik2.load_map_from_string(map, out_map.encode('utf8'))
        assert 'GlyphSymbolizer' in out_map
        # make sure non-ascii characters are well supported since most interesting
        # glyphs for symbology are usually in that range
        assert u'í' in out_map, out_map
    except RuntimeError, e:
        # only test datasources that we have installed
        if not 'Could not create datasource' in str(e):
            raise RuntimeError(e)
Beispiel #9
0
    def compare_map(in_map):
        
        mapnik2.load_map(map, in_map)

        (handle, test_map) = tempfile.mkstemp(suffix='.xml', prefix='mapnik-temp-map1-')
        os.close(handle)

        (handle, test_map2) = tempfile.mkstemp(suffix='.xml', prefix='mapnik-temp-map2-')
        os.close(handle)

        if os.path.exists(test_map):
            os.remove(test_map)
    
        mapnik2.save_map(map, test_map)
        new_map = mapnik2.Map(256, 256)
    
        mapnik2.load_map(new_map, test_map)
        open(test_map2,'w').write(mapnik2.save_map_to_string(new_map))
    
        diff = ' diff %s %s' % (os.path.abspath(test_map),os.path.abspath(test_map2))
        try:
            eq_(open(test_map).read(),open(test_map2).read())
        except AssertionError, e:
            raise AssertionError('serialized map "%s" not the same after being reloaded, \ncompare with command:\n\n$%s' % (in_map,diff))
def main(root,**options):
    m = mapnik.Map(1,1)
    
    idx = 0
    
    layers = []
    if hasattr(root,'NamedLayer'):
        layers.extend(root.NamedLayer)
    if hasattr(root,'UserLayer'):
        layers.extend(root.UserLayer)
    for layer in layers:
        lyr = mapnik.Layer(str(getattr(layer,'Name',None) or 'Layer'))
        datasource = options.get('datasource')
        if datasource and datasource.endswith('shp'):
            shp_dir = os.path.abspath(datasource).split('.shp')[0]
            name = datasource.split('.shp')[0]
            lyr.datasource = mapnik.Shapefile(file=shp_dir)
            if options.get('srid'):
                lyr.srs = '+init=epsg:%s' % options.get('srid')
                m.srs = lyr.srs
            else:
                srs = proj4_from_osr(shp_dir)
                if srs:
                    lyr.srs = srs
    
        for user_style in layer.UserStyle:
            for feature_style in user_style.FeatureTypeStyle:
                m_sty = mapnik.Style()
                # TODO = Styles should have title,abstract, etc...
                sty_name = getattr(feature_style,'Name',None)
                if not sty_name:
                    sty_name = '%s %s' % (lyr.name,str(idx))
                sty_name = str(sty_name)
    
                for rule in feature_style.Rule:
                    #print rule.get_childen()
                    m_rule = mapnik.Rule(str(getattr(rule,'Name','')))
                    ogc_filter = rule.find("{%s}Filter" % rule.nsmap['ogc'])
                    if ogc_filter is not None:
                        # TODO - support ogc:And and oc:Or
                        m_rule.filter = ogc_filter_to_mapnik(ogc_filter)
                    else:
                        if hasattr(rule,'ElseFilter'):
                              m_rule.set_else(True)
                    if hasattr(rule,'MaxScaleDenominator'):
                        m_rule.max_scale = float(rule.MaxScaleDenominator)
                    if hasattr(rule,'MinScaleDenominator'):
                        m_rule.min_scale = float(rule.MinScaleDenominator)                    
                    if hasattr(rule,'LineSymbolizer'):
                        stroke = rule.LineSymbolizer.Stroke
                        m_stroke = stroke_to_mapnik(stroke)
                        m_rule.symbols.append(mapnik.LineSymbolizer(m_stroke))
                    if hasattr(rule,'PolygonSymbolizer'):
                        fill = rule.PolygonSymbolizer.Fill
                        m_poly = fill_to_mapnik(fill)
                        m_rule.symbols.append(m_poly)
                    if hasattr(rule,'PointSymbolizer'):
                        #fill = rule.PolygonSymbolizer.Fill
                        #m_point = point_to_mapnik(point)
                        # TODO
                        m_rule.symbols.append(mapnik.PointSymbolizer())
                    if hasattr(rule,'TextSymbolizer'):
                        text = rule.TextSymbolizer
                        name = text.Label.find("{%s}PropertyName" % rule.nsmap['ogc'])
                        face_name = '[%s]' % text.Font

                        face_name = 'DejaVu Sans Book'
                        size = 10
                        for css in text.Font.CssParameter:
                           if css.get('name') == 'font-family':
                               face_name = css.text
                           elif css.get('name') == 'font-size':
                               size = int(float(css.text))
                        color = mapnik.Color('black')
                        for css in text.Fill.CssParameter:
                            if css.get('name') == 'fill':
                                color = mapnik.Color(css.text)
                        m_text = mapnik.TextSymbolizer(mapnik.Expression(str(name)),str(face_name),int(size),color)
                        if hasattr(text,'LabelPlacement'):
                            if hasattr(text.LabelPlacement,'LinePlacement'):
                                m_text.label_placement = mapnik.label_placement.LINE_PLACEMENT
                        if hasattr(text,'Halo'):
                            h = text.Halo
                            if hasattr(h,'Radius'):
                                m_text.halo_radius = float(h.Radius)
                            if hasattr(h,'Fill'):
                                for css in h.Fill.CssParameter:
                                    if css.get('name') == 'fill':
                                        m_text.halo_fill = mapnik.Color(css.text)
                            
                        m_rule.symbols.append(m_text)

                    m_sty.rules.append(m_rule)
                
                lyr.styles.append(sty_name)
                m.append_style(sty_name,m_sty)
                idx+= 1
                
    m.layers.append(lyr)
    if FIX_HEX:
        (handle, path) = tempfile.mkstemp(suffix='.xml', prefix='geotools2mapnik-')
        os.close(handle)
        open(path,'w').write(mapnik.save_map_to_string(m))
        tree = objectify.parse(path)
        fix_colors(tree)
        print etree.tostring(tree)#,pretty_print=True)
    else:
        print mapnik.save_map_to_string(m)
            sty_name = lay+'_shape'
            m.append_style(sty_name,sty)
            layer.styles.append(sty_name)
    
    if hit:
        m.layers.append(layer)

    text_rules = unique_layers[lay]['text_rules']
    if len(text_rules):
        sty = mapnik.Style()
        sty.filter_mode = mapnik.filter_mode.FIRST
        for rule in text_rules:
            # TODO - allow returning whole style for text and casings
            if catch:
                if catch in rule.name:
                    sty.rules.append(rule)
            else:
                sty.rules.append(rule)
        if len(sty.rules):
            hit = True
            sty_name = lay+'_text'
            m.append_style(sty_name,sty)
            text_layer = utils.copy_layer(layer)
            text_layer.styles.append(sty_name)
            text_layers.append(text_layer)

for lay in text_layers:
    m.layers.append(lay)

print mapnik.save_map_to_string(m)
def main(root,**options):
    m = mapnik.Map(1,1)
    
    idx = 0
    
    layers = []
    if hasattr(root,'NamedLayer'):
        layers.extend(root.NamedLayer)
    if hasattr(root,'UserLayer'):
        layers.extend(root.UserLayer)
    for layer in layers:
        lyr = mapnik.Layer(str(getattr(layer,'Name',None) or 'Layer'))
        datasource = options.get('datasource')
        if datasource and datasource.endswith('shp'):
            shp_dir = os.path.abspath(datasource).split('.shp')[0]
            name = datasource.split('.shp')[0]
            lyr.datasource = mapnik.Shapefile(file=shp_dir)
            if options.get('srid'):
                lyr.srs = '+init=epsg:%s' % options.get('srid')
                m.srs = lyr.srs
            else:
                srs = proj4_from_osr(shp_dir)
                if srs:
                    lyr.srs = srs
    
        for user_style in layer.UserStyle:
            for feature_style in user_style.FeatureTypeStyle:
                m_sty = mapnik.Style()
                # TODO = Styles should have title,abstract, etc...
                sty_name = getattr(feature_style,'Name',None)
                if not sty_name:
                    sty_name = '%s %s' % (lyr.name,str(idx))
                sty_name = str(sty_name)
    
                for rule in feature_style.Rule:
                    #print rule.get_childen()
                    m_rule = mapnik.Rule(str(getattr(rule,'Name','')))
                    ogc_filter = rule.find("{%s}Filter" % rule.nsmap['ogc'])
                    if ogc_filter is not None:
                        # TODO - support ogc:And and oc:Or
                        m_rule.filter = ogc_filter_to_mapnik(ogc_filter)
                    else:
                        if hasattr(rule,'ElseFilter'):
                              m_rule.set_else(True)
                    if hasattr(rule,'MaxScaleDenominator'):
                        m_rule.max_scale = float(rule.MaxScaleDenominator)
                    if hasattr(rule,'MinScaleDenominator'):
                        m_rule.min_scale = float(rule.MinScaleDenominator)                    
                    if hasattr(rule,'LineSymbolizer'):
                        stroke = rule.LineSymbolizer.Stroke
                        m_stroke = stroke_to_mapnik(stroke)
                        m_rule.symbols.append(mapnik.LineSymbolizer(m_stroke))
                    if hasattr(rule,'PolygonSymbolizer'):
                        m_poly = mapnik.PolygonSymbolizer()
                        if hasattr(rule.PolygonSymbolizer,'Fill'):
                            fill = rule.PolygonSymbolizer.Fill
                            for css in fill.CssParameter:
                                if css.get('name') == 'fill':
                                    m_poly.fill = mapnik.Color(css.text)
                                elif css.get('name') == 'fill-opacity':
                                    m_poly.opacity = float(css.text)
                                else:
                                    raise Exception('unhanded: ' + css.get('name'))
                        if hasattr(rule.PolygonSymbolizer,'Stroke'):
                            stroke = rule.PolygonSymbolizer.Stroke
                            m_stroke = stroke_to_mapnik(stroke)
                            m_rule.symbols.append(mapnik.LineSymbolizer(m_stroke))
                            
                        m_rule.symbols.append(m_poly)
                    if hasattr(rule,'PointSymbolizer'):
                        #fill = rule.PolygonSymbolizer.Fill
                        #m_point = point_to_mapnik(point)
                        # TODO
                        m_rule.symbols.append(mapnik.PointSymbolizer())
                    if hasattr(rule,'TextSymbolizer'):
                        text = rule.TextSymbolizer
                        name = text.Label.find("{%s}PropertyName" % rule.nsmap['ogc'])
                        if not name and hasattr(text,'Label'):
                            name = shlex.split(str(text.Label))[0]

                        face_name = '[%s]' % text.Font

                        face_name = 'DejaVu Sans Book'
                        size = 10
                        for css in text.Font.CssParameter:
                           if css.get('name') == 'font-family':
                               face_name = css.text
                           elif css.get('name') == 'font-size':
                               size = int(float(css.text))
                        color = mapnik.Color('black')
                        for css in text.Fill.CssParameter:
                            if css.get('name') == 'fill':
                                color = mapnik.Color(css.text)
                        m_text = mapnik.TextSymbolizer(mapnik.Expression('['+str(name)+']'),str(face_name),int(size),color)
                        if hasattr(text,'LabelPlacement'):
                            if hasattr(text.LabelPlacement,'LinePlacement'):
                                m_text.label_placement = mapnik.label_placement.LINE_PLACEMENT
                        if hasattr(text,'Halo'):
                            h = text.Halo
                            if hasattr(h,'Radius'):
                                m_text.halo_radius = float(h.Radius)
                            if hasattr(h,'Fill'):
                                for css in h.Fill.CssParameter:
                                    if css.get('name') == 'fill':
                                        m_text.halo_fill = mapnik.Color(css.text)
                            
                        m_rule.symbols.append(m_text)

                    m_sty.rules.append(m_rule)
                
                lyr.styles.append(sty_name)
                m.append_style(sty_name,m_sty)
                idx+= 1
                
    m.layers.append(lyr)
    if FIX_HEX:
        (handle, path) = tempfile.mkstemp(suffix='.xml', prefix='geotools2mapnik-')
        os.close(handle)
        open(path,'w').write(mapnik.save_map_to_string(m))
        tree = objectify.parse(path)
        fix_colors(tree)
        print etree.tostring(tree)#,pretty_print=True)
    else:
        print mapnik.save_map_to_string(m)