Image Vectorization Using C# – Convert raster image to vector graphic

Aspose.SVG offers a Free Online Image Vectorizer that is browser-based and works on any platform. Using this App, you may apply a set of options for obtaining the perfect result. Save your time and check this free Image Vectorizer to get all the benefits of vector graphics!

Convert Raster Images to SVG in C#

Image vectorization is the process of converting raster images such as PNG, JPG, BMP, GIF, or TIFF into scalable SVG vector graphics. Unlike bitmap images, SVG files preserve quality at any resolution and are easier to edit, optimize, and scale for web, print, CAD, and graphic design workflows.

Using Aspose.SVG for .NET, you can programmatically vectorize raster images in C# without external graphics software or browser-based tools. The API provides flexible vectorization settings that allow you to control path smoothing, curve simplification, color reduction, and SVG output complexity.

This article demonstrates how to:

• Convert raster images to SVG in C#.
• Customize vectorization settings.
• Smooth and simplify SVG paths.
• Reduce SVG file size.
• Improve vectorization quality for logos, icons, and illustrations.

Note: The Aspose.Svg.ImageVectorization namespace works with common bitmap formats (JPG, PNG, BMP, TIFF, GIF) and always produces an SVG file.

Convert PNG to SVG with TraceSimplifier

The Aspose.SVG image vectorization API provides classes and methods that allow you to work with various image preprocessing options before saving them in vector format.The processing assumes control of the following vectorization options: TraceSimplifier, TraceSmoother, ColorsLimit, and LineWidth.

Let’s look at how the TraceSimplifier property affects image vectorization. First of all, you need to know that:

• the ImageTraceSimplifier(tolerance) constructor takes as a parameter the tolerance and initializes an instance of the ImageTraceSimplifier class.
• the tolerance value determines the maximum error tolerance allowed for a point to be eliminated from the trace. It must be in the range of 0 to 4. The default value is 0.3.
• the ImageTraceSimplifier class is responsible for reducing the number of points in a curve that is approximated by a series of trace points.

The following code snippet demonstrates the use of different values of the tolerance (TraceSimplifier) property for image to vector conversion.

using System.IO;
using Aspose.Svg.ImageVectorization;
using Aspose.Svg.Saving;

// Compare different SplinePathBuilder configurations for image vectorization with varying simplification levels

// Initialize an instance of the ImageVectorizer class and specify configuration properties
ImageVectorizer vectorizer1 = new ImageVectorizer
{
    Configuration =
    {
        PathBuilder = new SplinePathBuilder
        {
            TraceSimplifier = new ImageTraceSimplifier(0.1f),
            TraceSmoother =   new ImageTraceSmoother(2),
        },
        ColorsLimit = 2
    }
};

ImageVectorizer vectorizer2 = new ImageVectorizer
{
    Configuration =
    {
        PathBuilder = new SplinePathBuilder
        {
            TraceSimplifier = new ImageTraceSimplifier(1),
            TraceSmoother =   new ImageTraceSmoother(2),
        },
        ColorsLimit = 2
    }
};

ImageVectorizer vectorizer3 = new ImageVectorizer
{
    Configuration =
    {
        PathBuilder = new SplinePathBuilder
        {
            TraceSimplifier = new ImageTraceSimplifier(2),
            TraceSmoother =   new ImageTraceSmoother(2),
        },
        ColorsLimit = 2
    }
};

// Prepare a path for a source image file
string sourcePath = Path.Combine(DataDir, "formats.png");

// Vectorize raster image from the specified file
using SVGDocument document1 = vectorizer1.Vectorize(sourcePath);
using SVGDocument document2 = vectorizer2.Vectorize(sourcePath);
using SVGDocument document3 = vectorizer3.Vectorize(sourcePath);

// Save the vectorized image as an SVG file
document1.Save(Path.Combine(OutputDir, "formats1.svg"));
document2.Save(Path.Combine(OutputDir, "formats2.svg"));
document3.Save(Path.Combine(OutputDir, "formats3.svg"));

Smooth Vector Paths with TraceSmoother

Sometimes fragments of contours look like sawtooth waves or appear jagged. Let’s look at how the TraceSmoother property affects contours’ smoothing. Before you start, know that:

• the ImageTraceSmoother class is responsible for smoothing the number of points in a curve that is approximated by a series of trace points. This class implements the Nearest Neighbor approach;
• the ImageTraceSmoother(severity) constructor takes as a parameter the severity and initializes an instance of the ImageTraceSmoother class;
• the value of the severity determines the extent of the region considered by query point. It must be in the range of 0 to 20.

Let’s look at how the TraceSmoother property affects image vectorization:

using System.IO;
using Aspose.Svg.ImageVectorization;
using Aspose.Svg.Saving;

// Vectorize PNG to SVG using ImageVectorizer and custom parameters

// Initialize an instance of the ImageVectorizer class
ImageVectorizer vectorizer = new ImageVectorizer
{
    // Optionally set a configuration
    Configuration =
    {
        // Optionally create an instance of the PathBuilder class
        PathBuilder = new BezierPathBuilder {
        // Optionally set trace smoother
        TraceSmoother = new ImageTraceSmoother(0),
            ErrorThreshold =  30,
            MaxIterations = 30
        },
        ColorsLimit = 10,
        LineWidth = 1
    }
};
// Vectorize image from the specified file
using SVGDocument document = vectorizer.Vectorize(Path.Combine(DataDir, "flower.png"));

// Save vectorized Image as an SVG file 
document.Save(Path.Combine(OutputDir, "flower.svg"));

Convert Photos to SVG in C#

Is it possible to convert a photo in vector format to look identical to the photo?

SVG is not well suited for drawing photorealistic images. Vector pictures do not allow for natural color transitions yet. Vector graphics are the best for creating logos, illustrations, technical drawings. It is not the most suitable format for continuous-tone images with blends of color or to edit photographs. However, vectorizing photos can result in impressive artistic effects that can be interesting and useful.

In this section, we convert a photo to vector format and try to choose vectorization options so that the result looks identical to the photo:

using System.IO;
using Aspose.Svg.ImageVectorization;
using Aspose.Svg.Saving;

// Convert JPG to SVG in C#

// Initialize an instance of the ImageVectorizer class
ImageVectorizer vectorizer = new ImageVectorizer
{
    // Optionally set a configuration
    Configuration =
    {
        // Optionally create an instance of the PathBuilder class
        PathBuilder = new SplinePathBuilder
        {
            TraceSmoother = new ImageTraceSmoother(1),
            TraceSimplifier = new ImageTraceSimplifier(0.3f)
        },
        ColorsLimit = 25,
        LineWidth = 1
    }
};

// Vectorize image from a specified file
using (SVGDocument document = vectorizer.Vectorize(Path.Combine(DataDir, "horses.jpg")))
{
    // Save the vectorized image as SVG
    document.Save(Path.Combine(OutputDir, "horses-new.svg"));
}

The figure demonstrates the source photo (a), the vectorized image using the code snippet (b) and the manually improved vectorized image (c).

As mentioned above, SVG is not the most suitable format for continuous-tone images with blends of color, etc. The vectorization process uses color image quantization. All small same colored spots or pixels, we replace by geometric shapes or curves. As a result, the borders of such graphic elements do not fit snugly together; gaps appear between them. This is the reason for the form of white spots and dots in the vectorized image.

Tip: To fix this problem, you can manually edit the resulting SVG file. We suggest changing the stroke-width="100" value to "150" or another, as you like. Try to get the best result!

The source photo (a) and resulting SVG file (c) you may find and view in details by following the links – horses.jpg, horses.svg.

Image Vectorization Configuration Options

Aspose.SVG for .NET provides multiple configuration options that allow you to control SVG quality, path smoothness, color reduction, and output complexity during image vectorization.

Careful adjustment of vectorization parameters helps optimize SVG output for logos, icons, illustrations, line art, and other raster graphics.

The following configuration properties are commonly used in image vectorization workflows:

Option	Description	Recommended Usage
ColorsLimit	Defines the maximum number of colors used during image quantization. Lower values simplify the SVG structure, while higher values preserve more image details.	Use lower values for logos and icons; higher values for detailed illustrations and photos.
ImageSizeLimit	Defines the maximum image dimension based on width × height. Large images may be automatically scaled before vectorization.	Increase this value for high-resolution source images to preserve details.
PathBuilder	Specifies the SVG path generation algorithm used during vectorization. Different path builders affect curve smoothness and contour behavior.	Use SplinePathBuilder or BezierPathBuilder for smoother SVG paths.
TraceSimplifier	Reduces the number of trace points and simplifies SVG geometry.	Helps reduce SVG file size and optimize path complexity.
TraceSmoother	Smooths contour fragments and reduces jagged edges in vector paths.	Recommended for noisy or low-quality raster images.
LineWidth	Defines the width of generated vector strokes.	Increase the value if thin contours disappear during vectorization.

License Limitations

A free evaluation version of Aspose.SVG for .NET provides all the features for image vectorization except the following:

• Only 4 dominant color will be used to quantize an image.
• Only 50% of SVG Document’s nodes will be saved during serialization.

If you want to try Aspose.SVG for .NET without evaluation limitations request a 30-day temporary license. For more information, please refer to How to get a Temporary License?.

The figure shows the result of the photo to vector conversion without applying a license.

The resulting SVG file you may find and view in details by following the links – horses-license.svg.

Common Image Vectorization Issues and Solutions

Problem	Possible Cause	Recommended Fix
The SVG contains many small gaps or disconnected shapes	ColorsLimit is too low, causing aggressive color reduction during tracing.	Increase ColorsLimit to preserve more color regions, for example 30–40. You can also slightly increase SVG stroke-width if necessary.
The generated SVG file is too large	TraceSimplifier tolerance is too low, so the algorithm preserves too many path points.	Increase the simplification tolerance to reduce path complexity. Typical values range from 0.7 to 1.0.
Vector edges appear rough or jagged	TraceSmoother is disabled or set too low.	Apply moderate smoothing values such as 5–10 to create cleaner SVG contours.
Some colors are missing in the output SVG	The evaluation version limits the number of processed dominant colors.	Apply a temporary or full Aspose.SVG license to enable full-color vectorization support.
The SVG contains too many unnecessary paths	The source image contains noise, gradients, or compression artifacts.	Preprocess the image before vectorization by reducing noise, increasing contrast, or using simpler source graphics.
Photo vectorization produces inaccurate results	Raster-to-vector tracing works best for logos, icons, and illustrations rather than detailed photographs.	Reduce the number of colors, increase smoothing, or use simplified artwork instead of photorealistic images.
Thin lines disappear after vectorization	Small details are removed during simplification or color reduction.	Lower the simplification tolerance and increase ColorsLimit to preserve fine details.

FAQ

1. How do I convert PNG to SVG in C#?
You can convert PNG images to SVG in C# using Aspose.SVG for .NET and the ImageVectorizer class. The API supports configurable vectorization settings for smoothing, simplification, and color reduction.

2. What is the difference between raster and vector images?
Raster images are composed of pixels and may lose quality when scaled. Vector graphics use mathematical paths and curves, allowing images to scale without quality loss.

3. How can I reduce SVG file size after vectorization?
You can reduce SVG complexity by increasing simplification tolerance, lowering the number of colors, and using smoother path generation settings.

4. Which images are best suited for vectorization?
Logos, icons, illustrations, line art, and simple graphics usually produce the best vectorization results because they contain clear edges and limited colors.

5. Can I customize the vectorization process?
Yes. Aspose.SVG for .NET allows you to configure color limits, path builders, smoothing, simplification, and image size settings to control SVG output quality.

Related Resources

• Image Vectorization Workflow – Describes the process of image vectorization and the available vectorization options.
• Image Stencil – Create stencils from images using the Aspose.SVG for .NET API.
• Text Vectorization – Convert SVG text to vector using the VectorizeText property of the SVGSaveOptions class.
• Image Vectorizer Online App – Try vectorization instantly in the browser.
• How to Run the Examples – Step‑by‑step guide for executing the sample projects.
• Temporary License FAQ – Answers to common licensing questions.