Python cairosvg.svg2png函数代码示例

    def read_svg(self, file_path):
        with open(file_path, 'r') as f:
            svg = f.read()

        svg = svg.format(w=self.width, h=self.height)
        img = cairosvg.svg2png(bytestring=svg.encode('utf-8'))
        img = Image.open(io.BytesIO(img))
        s = np.array(img)[:,:,3].astype(np.float) # / 255.0
        max_intensity = np.amax(s)
        s = s / max_intensity

        path_list = []        
        svg_xml = et.fromstring(svg)
        num_paths = len(svg_xml[0])

        for i in range(num_paths):
            svg_xml = et.fromstring(svg)
            svg_xml[0][0] = svg_xml[0][i]
            del svg_xml[0][1:]
            svg_one = et.tostring(svg_xml, method='xml')

            # leave only one path
            y_png = cairosvg.svg2png(bytestring=svg_one)
            y_img = Image.open(io.BytesIO(y_png))
            path = (np.array(y_img)[:,:,3] > 0)            
            path_list.append(path)

        return s, num_paths, path_list

    def read_svg(self, file_path):
        with open(file_path, 'r') as f:
            svg = f.read()

        img = cairosvg.svg2png(bytestring=svg.encode('utf-8'))
        img = Image.open(io.BytesIO(img))
        s = np.array(img)[:,:,3].astype(np.float) # / 255.0
        max_intensity = np.amax(s)
        if max_intensity == 0:            
            return s, 0, []
        s = s / max_intensity

        path_list = []        
        num_paths = svg.count('polyline')

        for i in range(1,num_paths+1):
            svg_xml = et.fromstring(svg)
            svg_xml[1] = svg_xml[i]
            del svg_xml[2:]
            svg_one = et.tostring(svg_xml, method='xml')

            # leave only one path
            y_png = cairosvg.svg2png(bytestring=svg_one)
            y_img = Image.open(io.BytesIO(y_png))
            path = (np.array(y_img)[:,:,3] > 0)            
            path_list.append(path)

        return s, num_paths, path_list

    def convert_svg_to_png(self):
        svg_files = glob(join(current_app.config['STATIC_PATH'], 'images',
                              'cards', '*.svg'))

        for svg_file in svg_files:
            png_file = svg_file.replace('.svg', '.png')
            svg2png(url=svg_file, write_to=png_file, width=2800, height=1500)

def exportsvg(inputDir, exportType, outputDir):
    if not os.path.exists(outputDir):
        os.mkdir(outputDir)
    num = 0
    for a,f,c in os.walk(inputDir):
        for fileName in c:
            path = os.path.join(a, fileName)
            if os.path.isfile(path) and fileName.endswith('.svg'):
                num += 1
                fileHandle = open(path)
                svg = fileHandle.read()
                fileHandle.close()
                exportPath = os.path.join(outputDir, fileName[:-3] + exportType)
                exportFileHandle = open(exportPath, 'w')

                if exportType == "png":
                    try:
                        cairosvg.svg2png(bytestring=svg, write_to=exportPath)
                    except:
                        print "error in convert svg file : %s to png."%(path)

                elif exportType == "pdf":
                    try:
                        cairosvg.svg2pdf(bytestring=svg, write_to=exportPath)
                    except:
                        print "error in convert svg file: %s to pdf."%(path)

                exportFileHandle.close()
                print "Success Export ", exportType, " -> ", exportPath

    print num, " files are tranformed from svg to ", exportType

    def convert_to_png(input_file, output_file, width=None, height=None):
        """Convert svg to png."""
        if width and height:
            handle = Rsvg.Handle()
            svg = handle.new_from_file(input_file)
            dim = svg.get_dimensions()

            img = ImageSurface(FORMAT_ARGB32, width, height)
            ctx = Context(img)
            ctx.scale(width / dim.width, height / dim.height)
            svg.render_cairo(ctx)

            png_io = BytesIO()
            img.write_to_png(png_io)
            with open(output_file, 'wb') as fout:
                fout.write(png_io.getvalue())
            fout.close()
            svg.close()
            png_io.close()
            img.finish()
        else:
            with open(input_file, "r") as content_file:
                svg = content_file.read()
            content_file.close()
            fout = open(output_file, "wb")
            svg2png(bytestring=bytes(svg, "UTF-8"), write_to=fout)
            fout.close()

def serve_content(svgFile=None):
    output = ''
    try:
        with open(os.path.join(app.root_path, 'roadmap.svg'), 'r') as file_obj:
            for oneline in file_obj:
                stringindex = oneline.find('<g')
                if stringindex == -1:
                    output += oneline
                    continue
                stringindex = oneline.find('id')
                if stringindex == -1:
                    output += oneline
                    continue
                tempstring = oneline[stringindex:]
                randomint = random.randint(0, len(colorlist)-1)
                onelist = oneline.split(' ')
                outputstr = onelist[0] + ' ' + onelist[1] + ' ' + 'fill=' + colorlist[randomint] + '>\n'
                output += outputstr
    
        with open(os.path.join(app.root_path, 'images/test.png'), 'wb') as file_output:
            cairosvg.svg2png(output, write_to=file_output)
        
        with open(os.path.join(app.root_path, 'images/test.png')) as f:
            response = make_response(f.read())
            response.headers['Content-Type'] = 'image/png'
            return response
    except:
        abort(make_response("dumped", 400))

def single_flake_png(path, string):
    fullpath = path + string + ".svg"
    pngpath = path + string + ".png"
    single_flake(path, string)
    #Convert the svg to PNG
    import cairosvg
    cairosvg.svg2png(url=fullpath, write_to=pngpath)

def cairosvg_svg_to_png(svg, dir_path, page_id):
    fout = open("%s/%d_thumbnail.png"%(dir_path,page_id),'wb')
    try:
        cairosvg.svg2png(bytestring=bytes(svg,'utf-8'),write_to=fout)
    except:
        logger.error(svg)
        traceback.print_exc()
    fout.close()

def svg2png_cli():

    import argparse
    ap = argparse.ArgumentParser()
    ap.add_argument('inputfiles', nargs="+")
    ap.add_argument('--target', default='png', help="Target file/filetype.")
    argns = ap.parse_args()
    for input_fn in argns.inputfiles:
        svg2png(input_fn, target=argns.target)

def save_image_to_png(path):
    try:
        import cairosvg
    except Exception as e:
        print("Vous devez installer 'cairosvg' pour pouvoir enregistrer votre image.")
        print("Pour en savoir plus : http://cairosvg.org/")
        exit(0)

    cairosvg.svg2png(url='{}.svg'.format(OUTPUT_NAME), write_to=path)

def writeFilesForSVG(svgstring, battle):
        f = open(os.path.expanduser('~/battles/results/' + battle + 'graphic.svg'), 'w')
        f.write(svgstring)
        f.close()
        
        fout = open(os.path.expanduser('~/battles/results/' + battle + 'graphic.png'), 'wb')
        cairosvg.svg2png(bytestring=svgstring.encode('utf-8'),write_to=fout)

        fout.close()

def prerendered_html_to_image(html, name, path=None):

    if path is not None:
        name = os.path.join(path, name)

    logger.info(name)
    svg = extract_svg(html)
    cairosvg.svg2png(bytestring=svg, write_to=name)
    return svg[:10]

    def debug_and_draw(self, X, masks_idx, output_dir, show_notebook=False,
                       n=None):
        def encode64_png(np_array):
            output = io.BytesIO()
            scipy.misc.toimage(np_array).save(output, format='PNG')
            return base64.b64encode(output.getvalue())

        def make_image(elem: et.Element, np_array):
            elem.tag = '{http://www.w3.org/2000/svg}image'
            arr_base64 = encode64_png(np_array)
            elem.set('{http://www.w3.org/1999/xlink}href', "data:image/png;base64," +
                     arr_base64.decode('utf-8'))

        def set_text(elem: et.Element, text):
            children = list(elem)
            for c in children:
                elem.remove(c)
            elem.text = str(text[0])

        if n is None:
            n = len(X)

        outputs = self.debug(X, masks_idx)
        output_dict = dict(zip(self.debug_labels, outputs))
        d_out_real = {"d64_real": "charlie_d",
                      "d32_real": "bravo_d",
                      "d16_real": "alfa_d"}
        d_out_fake = {"d64_fake": "charlie_d",
                      "d32_fake": "bravo_d",
                      "d16_fake": "alfa_d"}

        for i in range(n):
            with open('lapgan.svg') as f:
                tree = et.parse(f)

            labels = self.debug_labels
            for elem in tree.iter():
                id = elem.get('id')
                if id is not None:
                    id = id.split("XXX")[0]
                if id in labels:
                    index = labels.index(id)
                    make_image(elem, outputs[index][i, 0])
                if id in list(d_out_real.keys()):
                    index = labels.index(d_out_real[id])
                    set_text(elem, outputs[index][i])
                if id in list(d_out_fake.keys()):
                    index = labels.index(d_out_fake[id])
                    set_text(elem, outputs[index][i+self.batch_size//2])

            svg_code = et.tostring(tree.getroot())
            fname = output_dir + "/{}.png".format(i)
            cairosvg.svg2png(bytestring=svg_code, write_to=fname)
            if show_notebook:
                import IPython.display
                IPython.display.Image(filename=fname)

def str2png(svg_str, out_file):
	u'''
		SVG 文字列を PNG ﾌｧｲﾙへ出力する
	'''
	global svg_header

	svg = svg_header + svg_str + '</svg>'

	#print svg
	cairosvg.svg2png(bytestring=svg,write_to=out_file)

def preprocess_path(file_path, w, h, rng):
    with open(file_path, 'r') as f:
        svg = f.read()

    img = cairosvg.svg2png(bytestring=svg.encode('utf-8'))
    img = Image.open(io.BytesIO(img))
    s = np.array(img)[:,:,3].astype(np.float) # / 255.0
    max_intensity = np.amax(s)
    if max_intensity == 0:
        x = np.zeros([h, w, 2])
        y = np.zeros([h, w, 1])
        return x, y
    s = s / max_intensity

    while True:
        svg_xml = et.fromstring(svg)
        num_paths = svg.count('polyline')
        path_id = rng.randint(1,num_paths+1)
        svg_xml[1] = svg_xml[path_id]
        del svg_xml[2:]
        svg_one = et.tostring(svg_xml, method='xml')

        # leave only one path
        y_png = cairosvg.svg2png(bytestring=svg_one)
        y_img = Image.open(io.BytesIO(y_png))
        y = np.array(y_img)[:,:,3].astype(np.float) / max_intensity # [0,1]

        pixel_ids = np.nonzero(y)
        # assert len(pixel_ids[0]) > 0, '%s: no stroke px' % file_path
        if len(pixel_ids[0]) > 0:
            break

    # select arbitrary marking pixel
    point_id = rng.randint(len(pixel_ids[0]))
    px, py = pixel_ids[0][point_id], pixel_ids[1][point_id]

    y = np.reshape(y, [h, w, 1])
    x = np.zeros([h, w, 2])
    x[:,:,0] = s
    x[px,py,1] = 1.0

    # # debug
    # plt.figure()
    # plt.subplot(221)
    # plt.imshow(img)
    # plt.subplot(222)
    # plt.imshow(s, cmap=plt.cm.gray)
    # plt.subplot(223)
    # plt.imshow(np.concatenate((x, np.zeros([h, w, 1])), axis=-1))
    # plt.subplot(224)
    # plt.imshow(y[:,:,0], cmap=plt.cm.gray)
    # plt.show()

    return x, y