Image Vectorization – C# code and Online Vectorizer

What is Image Vectorization?

Image vectorization is the powerful process of converting standard bitmap images into mathematically scalable vector graphics – such as Bezier curves, splines, and lines. The primary advantage of vectorization is that your images will never pixelate when enlarged. Scaling without losing quality, incredibly small file sizes, and seamless animation support are just a few benefits of working with vector graphics. Using the Aspose.SVG for .NET API , you can implement a high-speed C# vectorization process that gives you complete control over how your raster images are traced and converted into clean SVG files.

Online Image Vectorizer

Our interactive Image Vectorizer is designed to convert raster images into vector graphics instantly. It creates precise geometric shapes consisting of Bezier curves and lines, saving all generated elements into a clean SVG file. The tool supports almost all standard bitmap formats, including JPEG, PNG, BMP, ICO, GIF, TIFF, and WEBP. You can easily test out different vectorization options, such as color limits and smoothing, directly in your browser before downloading the final scalable vector art!

How to use Image Vectorizer?

1. Load your source raster image from your local file system. The UI presents three panels: Source Image, Quantized Image, and Vectorized Image.
2. The engine evaluates the Image using default properties. To optimize the SVG output, use the sidebars to tune the quantization and vectorization parameters. Click Quantize to preview palette reduction, then Vectorize to render the SVG paths.
3. Click Download to save the generated vector file.

Quantization Options

Adjust these settings to govern how the algorithm groups pixels and reduces the initial color palette:

• colors - Sets the exact maximum palette size constraint.
• method - Switches between histogram-based color quantization algorithms.
• minHueCols - Controls sensitivity limits for handling color gradients.
• scale - Adjusts the scaling factor for finer or coarser color sampling.
• grayscale - Forces the output to monochromatic boundaries.

Vectorization Options

Control the geometric tracing behavior applied to the quantized map:

• threshold - Defines the pixel sensitivity constraint for detecting boundary contours.
• severity - Modifies contour smoothing using Nearest Neighbor spatial sizing.
• line-width - Determines the stroke thickness assigned to generated SVG lines.
• stencil - Applies a binary outline mask, ideal for converting continuous-tone photographs into stenciled silhouettes.
• trace paths - Toggles the visual rendering of the Bezier curve and spline control points used to build segments.
  
  

How to Vectorize Image in C#

The Aspose.SVG for .NET API provides a dedicated ImageVectorization namespace that handles all the heavy lifting of converting images to vectors. With these classes, you can easily control various pre-processing options – such as adjusting the ColorsLimit to simplify the image, or applying a TraceSmoother within your PathBuilder to remove jagged pixel edges – before saving the final output in vector format.

    // Initialize an instance of the ImageVectorizer class
    ImageVectorizer vectorizer = new ImageVectorizer
    {
        // Optionally set a configuration and specify configuration properties
        Configuration =
        {
            // Optionally create an instance of the PathBuilder class
            PathBuilder = new BezierPathBuilder 
            {
                // Optionally set trace smoother
                TraceSmoother = new ImageTraceSmoother(1),
                ErrorThreshold = 30,
                MaxIterations = 30
            },
            ColorsLimit = 25,
            LineWidth = 1
        }
    };
    
    // Vectorize image from the specified file
    using (SVGDocument document = vectorizer.Vectorize(Path.Combine(DataDir, "image.png")))
    {
        // Save vectorized image as SVG file
        document.Save(Path.Combine(OutputDir, "image.svg"));
    }

Steps to Vectorize Image in C#

Converting a raster image into a scalable vector model in C# requires just three straightforward steps:

1. Initialize an instance of the ImageVectorizer class and set up its Configuration properties.
   • Use the ColorsLimit to define the maximum number of colors tracing can use, optimizing the image size.
   • Attach a BezierPathBuilder to accurately build smooth curves from pixel contours.
   • Apply the ImageTraceSmoother to neatly smooth out any rough or jagged edges.
2. Call the Vectorize() method, passing the path to your source image, to create an active SVGDocument.
3. Save the resulting vector image to your file system using the basic Save() method.

Image Vectorization in Documentation

Scalable Vector Graphics (SVG) are currently the standard for rendering high-quality web graphics because they create sharp images that scale to any size without losing quality. To master how this conversion works, explore our Vectorization – Basic Overview guide.

• Image Vectorization Workflow – Delivers a clear breakdown of the vectorization options, showing you exactly how to trace raster images into standard SVG documents.
• Image Vectorization Examples – Browse real-world C# examples that demonstrate how adjusting configuration settings directly affects your final vector result.

FAQ

Get Started with Aspose.SVG for .NET API