Render Presentation Slides as SVG Images in Python

What this page is about

Export PowerPoint slides as SVG images in Python and control fonts, text, and images with Aspose.Slides.

Overview

SVG is a scalable XML-based image format that works well for web publishing, slide viewers, accessibility workflows, and automated post-processing. Aspose.Slides exports each slide to a separate SVG file and lets you control how text, fonts, pictures, and SVG elements are written.

Use SVGOptions when the exported SVG must be compact, predictable across browsers, or ready for interactive use.

Export a Slide as SVG

Create a Presentation, select a slide, and write it to a stream. The following example exports every slide in a presentation as a separate SVG file.

import aspose.slides as slides

with slides.Presentation("presentation.pptx") as presentation:
    for slide in presentation.slides:
        with open("slide-{}.svg".format(slide.slide_number), "wb") as svg_stream:
            slide.write_as_svg(svg_stream)

The filename uses Slide.slide_number rather than the loop index. You can also export an individual shape with Shape.write_as_svg when a slide viewer or web page needs only that shape.

Configure SVG Output

SVGOptions controls SVG rendering. For text frames, SVGOptions.use_frame_size includes the text frame in the rendering area, and SVGOptions.use_frame_rotation determines whether the frame rotation is applied. Set SVGOptions.disable_font_ligatures to True when text must be rendered without ligatures.

import aspose.slides as slides

with slides.Presentation("presentation.pptx") as presentation:
    svg_options = slides.export.SVGOptions()
    svg_options.disable_font_ligatures = True
    svg_options.use_frame_size = True
    svg_options.use_frame_rotation = False

    with open("slide-with-custom-options.svg", "wb") as svg_stream:
        presentation.slides[0].write_as_svg(svg_stream, svg_options)

Control Line-End Cropping at Arrowheads

SVG 1.1 has no marker inset setting to specify where a line should stop beneath an arrowhead. By default, Aspose.Slides shortens the exported line so its stroke does not protrude through the marker. Set SVGOptions.disable_line_end_cropping to True to draw the stroke all the way to the line’s original endpoint. This setting affects only the SVG output. The line keeps its position and length on the slide.

The example draws triangle and diamond arrowheads on lines 2 and 10 points wide. It exports the same slide twice, changing only the cropping option.

import aspose.pydrawing as drawing
import aspose.slides as slides

with slides.Presentation() as presentation:
    slide = presentation.slides[0]
    y = 40

    for style in (slides.LineArrowheadStyle.TRIANGLE, slides.LineArrowheadStyle.DIAMOND):
        for width in (2, 10):
            line = slide.shapes.add_auto_shape(slides.ShapeType.LINE, 40, y, 200, 0)
            line_format = line.line_format
            line_format.fill_format.fill_type = slides.FillType.SOLID
            line_format.fill_format.solid_fill_color.color = drawing.Color.dark_blue
            line_format.width = width
            line_format.end_arrowhead_style = style
            y += 50

    options = slides.export.SVGOptions()
    options.disable_line_end_cropping = False
    with open("cropped.svg", "wb") as cropped:
        slide.write_as_svg(cropped, options)

    options.disable_line_end_cropping = True
    with open("uncropped.svg", "wb") as uncropped:
        slide.write_as_svg(uncropped, options)

The comparison shows the triangular arrowhead on the 10-point line. With cropping enabled, the tip is sharp. With cropping disabled, the stroke protrudes through the sloping sides of the marker and leaves a flat end.

Enlarged 10-point triangle with a sharp tip when cropping is enabled and a flat end when cropping is disabled

In the other lines from the example, the protruding stroke is less visible on the 2-point triangle. The filled diamond covers the end of the stroke at both widths.

Control Text and Fonts

When exporting slides to SVG, you can control whether text remains as text or is converted to vector graphics, and how external fonts are included or referenced. The following options help you balance visual consistency, text selection, and font dependencies in the exported SVG.

Vectorize All Text

Set SVGOptions.vectorize_text to True to write all slide text as vector graphics. This eliminates font dependencies and makes the visual result more consistent across browsers, but the text is no longer selectable or searchable as SVG text.

import aspose.slides as slides

with slides.Presentation("presentation.pptx") as presentation:
    svg_options = slides.export.SVGOptions()
    svg_options.vectorize_text = True

    with open("slide-with-vectorized-text.svg", "wb") as svg_stream:
        presentation.slides[0].write_as_svg(svg_stream, svg_options)

Choose How External Fonts Are Handled

SVGOptions.external_fonts_handling uses a SvgExternalFontsHandling value for fonts that are loaded externally. Choose ADD_LINKS_TO_FONT_FILES to reference separate font files, EMBED to include font data in the SVG, or VECTORIZE to render only text that uses external fonts as graphics. Verify font licensing before embedding fonts.

import aspose.slides as slides

with slides.Presentation("presentation.pptx") as presentation:
    linked_fonts_options = slides.export.SVGOptions()
    linked_fonts_options.external_fonts_handling = slides.export.SvgExternalFontsHandling.ADD_LINKS_TO_FONT_FILES

    with open("slide-with-font-links.svg", "wb") as linked_fonts_stream:
        presentation.slides[0].write_as_svg(linked_fonts_stream, linked_fonts_options)

    embedded_fonts_options = slides.export.SVGOptions()
    embedded_fonts_options.external_fonts_handling = slides.export.SvgExternalFontsHandling.EMBED

    with open("slide-with-embedded-fonts.svg", "wb") as embedded_fonts_stream:
        presentation.slides[0].write_as_svg(embedded_fonts_stream, embedded_fonts_options)

    vectorized_external_fonts_options = slides.export.SVGOptions()
    vectorized_external_fonts_options.external_fonts_handling = slides.export.SvgExternalFontsHandling.VECTORIZE

    with open("slide-with-vectorized-external-fonts.svg", "wb") as vectorized_external_fonts_stream:
        presentation.slides[0].write_as_svg(vectorized_external_fonts_stream, vectorized_external_fonts_options)

Reduce Embedded Image Size

Use SVGOptions.pictures_compression to reduce the resolution of embedded pictures, SVGOptions.delete_pictures_cropped_areas to omit cropped source areas, and SVGOptions.jpeg_quality to control JPEG encoding quality. These settings reduce file size at the cost of image fidelity or retained image data.

import aspose.slides as slides

with slides.Presentation("presentation.pptx") as presentation:
    svg_options = slides.export.SVGOptions()
    svg_options.pictures_compression = slides.export.PicturesCompression.DPI150
    svg_options.delete_pictures_cropped_areas = True
    svg_options.jpeg_quality = 80

    with open("compressed-slide.svg", "wb") as svg_stream:
        presentation.slides[0].write_as_svg(svg_stream, svg_options)

Control Metafile Rasterization Resolution

SVGOptions.metafile_rasterization_dpi sets the lower resolution limit for rasterizing metafiles during SVG export. Use it to balance detail and file size when an EMF or WMF image is rasterized. It does not define a global DPI for the SVG or force every object on the slide to become a raster image.

Download metafile-rasterization.pptx, which contains an EMF image with closely spaced diagonal lines. The following example exports its first slide at three rasterization resolutions through Slide.write_as_svg. All other export settings remain identical so that the results can be compared.

import aspose.slides as slides

with slides.Presentation("metafile-rasterization.pptx") as presentation:
    for dpi in (72, 150, 300):
        svg_options = slides.export.SVGOptions()
        svg_options.metafile_rasterization_dpi = dpi
        svg_options.pictures_compression = slides.export.PicturesCompression.DPI330
        svg_options.jpeg_quality = 90

        with open("slide-{}.svg".format(dpi), "wb") as svg_stream:
            presentation.slides[0].write_as_svg(svg_stream, svg_options)

In the output, the EMF became one embedded PNG in each SVG. The following measurements are for the supplied presentation; they are not a general formula for converting DPI to pixel dimensions.

Metafile rasterization DPI	Embedded PNG dimensions	SVG file size (bytes)
72	1196 × 596	170,221
150	2492 × 1242	423,149
300	4983 × 2483	1,027,169

The comparison below shows the same area of the embedded raster at the same enlarged display size. The diagonal lines show visible pixelation at 72 DPI and smoother edges at higher resolutions, while the SVG file grows. Increasing the value does not necessarily improve every detail or change every exported image.

Enlarged diagonal-line detail at 72, 150, and 300 DPI

SVGOptions.pictures_compression controls image resolution reduction and can mask the effect of changing the metafile rasterization resolution. SVGOptions.jpeg_quality controls JPEG encoding quality, not metafile rasterization resolution.

FAQ

When should I use SVGOptions.vectorize_text instead of SvgExternalFontsHandling.VECTORIZE?

Use SVGOptions.vectorize_text when all text must be independent of fonts. Use SvgExternalFontsHandling.VECTORIZE when only text that uses external fonts should be converted to graphics.

What is the best way to make an SVG smaller?

Start by compressing embedded pictures, deleting cropped image areas, and choosing linked font files when the target environment can serve them. Test the result because lower image resolution, lower JPEG quality, and vectorized text each have different quality and size tradeoffs.

Convert PPT & PPTX to PDF in Python | Advanced Options Convert PPT, PPTX, and ODP to JPG in Python