Convert an SVG image to PNG/JPEG/PDF

If you have an SVG image, you can convert it into the PNG, JPEG, or PDF formats. Save the SVG in a file, for example, chart.svg. Then set the SVG path using the --inputSVG option. To convert an SVG image to PNG/JPEG/PDF, you can use the CLI or SDKs of the languages mentioned below, using the command given below:

If you have an SVG image, you can convert it into the PNG, JPEG, or PDF formats. To do this:
Step 1
Save the SVG in a file and name it, let’s say, chart.svg.
Step 2
Use the --input-file or -i options to convert the image into the required format using FusionExport, as shown below:

    $ fe -i chart.svg -t pdf


    // Converting an SVG image to PNG/JPEG/PDF
    const path = require('path');

    // Require FusionExport
    const {
        ExportManager,
        ExportConfig
    } = require('../');

    // Instantiate ExportManager
    const exportManager = new ExportManager();

    // Instantiate ExportConfig and add the required configurations
    const exportConfig = new ExportConfig();

    exportConfig.set('inputSVG', path.join(dirname, 'resources', 'vector.svg'));

    // provide the export config
    exportManager.export(exportConfig);

    // Called when export is done
    exportManager.on('exportDone', (outputFileBag) => {
        outputFileBag.forEach((op) => {
            console.log(DONE: ${op.realName});
        });

        ExportManager.saveExportedFiles(outputFileBag);
    });

    // Called on each export state change
    exportManager.on('exportStateChange', (state) => {
        console.log([${state.reporter}] ${state.customMsg});
    });

    // Called on erroe
    exportManager.on('error', (err) => {
        console.error(err);
    });


    import com.fusioncharts.fusionexport.client.*; // import sdk

    public class ExportChart {
        public static void main(String[] args) throws Exception {

            String svgPath = "fullpath/resources/static/sample.svg";

            // Instantiate the ExportConfig class and add the required configurations
            ExportConfig config = new ExportConfig();
            config.set("inputSVG", svgPath);

            // Instantiate the ExportManager class
            ExportManager manager = new ExportManager(config);
            // Call the export() method with the export config and the respective callbacks
            manager.export(new ExportDoneListener() {
                    @Override
                    public void exportDone(ExportDoneData result, ExportException error) {
                        if (error != null) {
                            System.out.println(error.getMessage());
                        } else {
                            ExportManager.saveExportedFiles("fullPath", result);
                        }
                    }
                },
                new ExportStateChangedListener() {
                    @Override
                    public void exportStateChanged(ExportState state) {
                        System.out.println("STATE: " + state.reporter);
                    }
                });
        }
    }


    using System;
    using System.IO;
    using System.Linq;
    using FusionCharts.FusionExport.Client; // Import sdk

    namespace FusionExportTest {
        public static class ConvertSvg {
            public static void Run(string host = Constants.DEFAULT_HOST, int port = Constants.DEFAULT_PORT) {
                // Instantiate the ExportConfig class and add the required configurations
                ExportConfig exportConfig = new ExportConfig();
                exportConfig.Set("inputSVG", "./resources/chart.svg");

                // Instantiate the ExportManager class
                ExportManager em = new ExportManager(host: host, port: port);
                // Call the Export() method with the export config and the respective callbacks
                em.Export(exportConfig, OnExportDone, OnExportStateChanged);
            }

            // Called when export is done
            static void OnExportDone(ExportEvent ev, ExportException error) {
                if (error != null) {
                    Console.WriteLine("Error: " + error);
                } else {
                    var fileNames = ExportManager.GetExportedFileNames(ev.exportedFiles);
                    Console.WriteLine("Done: " + String.Join(", ", fileNames)); // export result
                }
            }

            // Called on each export state change
            static void OnExportStateChanged(ExportEvent ev) {
                Console.WriteLine("State: " + ev.state.customMsg);
            }
        }
    }


    <?php
    // Converting an SVG image to PNG/JPEG/PDF
    require DIR__ . '/../vendor/autoload.php';
    // Use the sdk
    use FusionExport\ExportManager;
    use FusionExport\ExportConfig;
    // Instantiate the ExportConfig class and add the required configurations
    $exportConfig = new ExportConfig();
    $exportConfig->set('inputSVG', realpath('resources/vector.svg'));
    // Called on each export state change
    $onStateChange = function ($event) {
        $state = $event->state;
        echo('STATE: [' . $state->reporter . '] ' . $state->customMsg . "\n");
    };
    // Called when export is done
    $onDone = function ($event, $e) {
        $export = $event->export;
        if ($e) {
            echo('ERROR: ' . $e->getMessage());
        } else {
            foreach ($export as $file) {
                echo('DONE: ' . $file->realName. "\n");
            }
            ExportManager::saveExportedFiles($export);
        }
    };
    // Instantiate the ExportManager class
    $exportManager = new ExportManager();
    // Call the export() method with the export config and the respective callbacks
    $exportManager->export($exportConfig, $onDone, $onStateChange);


    #!/usr/bin/env python

    from fusionexport import ExportManager, ExportConfig  # Import sdk

    # Called when export is done
    def on_export_done(event, error):
        if error:
            print(error)
        else:
            ExportManager.save_exported_files("exported_images", event["result"])


    # Called on each export state change
    def on_export_state_changed(event):
        print(event["state"])


    # Instantiate the ExportConfig class and add the required configurations
    export_config = ExportConfig()
    export_config["inputSVG"] = "chart.svg"

    # Provide port and host of FusionExport Service
    export_server_host = "127.0.0.1"
    export_server_port = 1337

    # Instantiate the ExportManager class
    em = ExportManager(export_server_host, export_server_port)
    # Call the export() method with the export config and the respective callbacks
    em.export(export_config, on_export_done, on_export_state_changed)


    // Converting an SVG image to PNG/JPEG/PDF

    package main

    import (
        "fmt"

        "github.com/fusioncharts/fusionexport-go-client"
    )

    // Called when export is done
    func onDone(outFileBag []FusionExport.OutFileBag, err error) {
        check(err)
        FusionExport.SaveExportedFiles(outFileBag)
    }

    // Called on each export state change
    func onStateChange(event FusionExport.ExportEvent) {
        fmt.Println("[" + event.Reporter + "] " + event.CustomMsg)
    }

    func main() {
        // Instantiate ExportConfig and add the required configurations
        exportConfig := FusionExport.NewExportConfig()

        exportConfig.Set("inputSVG", "example/resources/vector.svg")

        // Instantiate ExportManager
        exportManager := FusionExport.NewExportManager()
        // Call the Export() method with the export config and the respective callbacks
        exportManager.Export(exportConfig, onDone, onStateChange)
    }

    func check(e error) {
        if e != nil {
            panic(e)
        }
    }
Was this article helpful to you ?
Where do you think this article needs improvement?