Vectorisation d'images – Workflow – .NET

Cet article explique comment convertir des bitmaps en graphiques vectoriels à l’aide de l’API Aspose.SVG. Vous y trouverez une description du processus de vectorisation d’images; Utilisation des algorithmes et des options de vectorisation, apprenez à vectoriser des images raster telles que PNG, JPG, BMP, TIFF, GIF, ICO dans un document SVG.

Aspose.SVG propose un Vectoriseur d’image en ligne gratuit basé sur un navigateur et fonctionnant sur n’importe quelle plate-forme. En utilisant cette application, vous pouvez appliquer un ensemble d’options pour obtenir le résultat parfait. Économisez votre temps et consultez ce vecteur d’image gratuit pour bénéficier de tous les avantages des graphiques vectoriels!

Qu’est-ce que la vectorisation d’images?

La tâche de la vectorisation est de convertir une image 2D en une représentation vectorielle 2D de l’image. Les graphiques vectoriels bidimensionnels sont des images infographiques représentées sous forme de courbes mathématiques. Ces images vectorielles sont définies comme des points cartésiens reliés par des lignes et des courbes pour former les formes requises. Une image raster est un ensemble de pixels. S’il s’agit d’une image RGB, elle peut être représentée sous forme d’un tableau de pixels de couleur. Chaque pixel est un triplet de valeurs entières de 8 bits, chaque valeur représentant une quantité de couleur rouge, verte et bleue.

La vectorisation d’images est le processus de conversion d’images raster en graphiques vectoriels – les courbes, splines et lignes de Bézier.

L’image source pour la conversion raster en vecteur peut accepter les formats bitmap tels que JPG, TIFF, BMP, GIF et PNG. L’image de sortie est un format de fichier vectoriel, par exemple le format de fichier SVG. Les images telles que les cartes, les icônes, les logos, les dessins techniques et les images clipart conviennent à la vectorisation. Ces images sont basées sur des formes géométriques et dessinées avec des courbes simples.

A quoi sert la vectorisation d’images?

Mise à l’échelle et taille. Les images raster sont basées sur les pixels et dépendent donc de la résolution. La qualité de l’image dépend du nombre de pixels qui composent l’image et de la valeur de résolution qui détermine le nombre de pixels affichés par pouce. Par conséquent, plus l’image contient de pixels et plus la résolution est élevée, plus la qualité de l’image est élevée. Par exemple, la mise à l’échelle d’un bitmap pour l’agrandir sans modifier la résolution perdra en qualité et apparaîtra floue ou pixellisée. En effet, les pixels sont étirés sur une zone plus grande, ce qui les rend moins nets. Contrairement aux graphiques bitmap, les images vectorielles sont redimensionnables et évolutives sans perdre aucune qualité, et elles s’afficheront toujours aussi clairement. En d’autres termes, les graphiques vectoriels présentent un avantage unique par rapport aux graphiques raster dans la mesure où les points, les lignes et les courbes peuvent être agrandis ou réduits sans perte de qualité.

Sécurité et confidentialité. Il est parfois nécessaire de protéger les images des techniques de reconnaissance d’images comme la reconnaissance faciale. Les images vectorisées sont plus résistantes à de telles attaques car les outils de reconnaissance d’images sont généralement orientés pixels.

Récupération d’images. La vectorisation peut être utilisée pour mettre à jour ou récupérer des images.

Processus de vectorisation d’images

Le processus de vectorisation d’image comprend les étapes suivantes:

Quantisation et redimensionnement des couleurs. La quantification des couleurs ou quantification des images couleur est une quantification appliquée aux espaces colorimétriques. Il s’agit d’un processus qui réduit le nombre de couleurs différentes utilisées dans une image, dans le but que la nouvelle image soit aussi visuellement similaire que possible à l’image originale. Dans notre processus de vectorisation d’images, la quantification des couleurs joue un rôle important car elle réduit le nombre de couleurs utilisées qui affectent considérablement la taille et la qualité du SVG vectorisé. Lorsque l’image est énorme ou contient beaucoup de petits points ou pixels de même couleur, nous la redimensionnons pour éviter que le document SVG ne soit trop grand.

Traçage des contours. Le traçage des contours ou traçage des limites est une technique appliquée aux images numériques pour extraire leur ou leurs limites pour les images non monochromes. Il existe plusieurs techniques de ce type comme Suzuki-Abe, Moore-neighbour, Square Tracing Algorithm, Theo Pavlidis’ Algorithm, etc. Malheureusement, ces algorithmes fonctionnent avec des images monochromes et le font de manière non optimale avec des images multicolores. Nous avons donc développé un nouvel algorithme de suivi des contours qui fonctionne rapidement et avec précision avec des images multicolores et réduit considérablement le nombre de contours.

Lissage des traces (cette étape est facultative). Parfois, des fragments de contours ressemblent à des ondes en dents de scie car la résolution des images vectorisées n’est pas assez élevée ou il y a du bruit dans l’image. Pour le lissage, ces courbes peuvent être utilisées de nombreuses approches telles que la régression linéaire locale, la régression polynomiale locale, le noyau gaussien, etc. Nous avons constaté que des résultats parfaits peuvent être obtenus à l’aide de l’approche du voisin le plus proche, qui a été implémentée dans le logiciel ImageTraceSmoother classe.

Simplification des traces (facultatif). À cette étape, il est nécessaire de décimer la courbe de trace composée de segments de ligne en une courbe similaire avec moins de points. Il existe différents algorithmes comme Ramer – Douglas – Peucker, Visvalingam – Whyatt, Reumann – Witkam, etc. qui peuvent être utilisés pour résoudre cette tâche. Nous avons implémenté l’approche Ramer – Douglas – Peucker dans la classe ImageTraceSimplifier car elle a montré un meilleur résultat que d’autres dans nos expériences, mais nous avons déclaré l’interface IImageTraceSimplifier pour implémenter toute autre approche.

Création d’éléments de chemin SVG à partir des traces. La dernière étape consiste à convertir les points de traçage en lignes de chemin SVG et en courbes de Bézier et à les ajouter au document SVG. Pour ajuster les courbes passant par chaque point de tracé, nous utilisons une spline Catmull-Roma, qui est convertie en courbes de Bézier.

Options de vectorisation

Vous pouvez convertir une image raster en graphique vectoriel à l’aide des options de configuration par défaut ou personnalisées. Vous pourrez appliquer des paramètres personnalisés pour obtenir le meilleur résultat de conversion d’image en vecteur et enregistrer le fichier SVG de sortie sur votre ordinateur. Le traitement prend le contrôle des propriétés suivantes :

Property	Description
ColorsLimit	This property gets or sets the maximum number of colors used to quantize an image. The default value is 25.
ImageSizeLimit	Gets or sets maximal dimension of an image determined by multiplication image width and height. The size of the image will be scaled based on this property. The default value is 1800000.
PathBuilder	This property sets the SVG path segments builder and affects how sharply the curve bends at the control points.
TraceSimplifier	The property sets the trace simplified. As a result, the trace curve will be built composed of line segments with fewer (or bigger) points.
TraceSmoother	This property sets the trace smoother. It is used to smooth out fragments of contours.

Exemple C#

L’API Aspose.HTML fournit un espace de noms ImageVectorization qui réalise diverses classes permettant d’implémenter un ensemble d’algorithmes pour le processus de vectorisation d’image. Les classes et méthodes fournies vous permettent de travailler avec plusieurs options de vectorisation pour prétraiter les images avant de les enregistrer au format vectoriel.

Remarque: L’API Aspose.SVG vise à implémenter des tâches de vectorisation d’image, de sorte que l’image source vers la conversion raster en vecteur peut accepter des formats bitmap tels que JPG, PNG, BMP, TIFF, GIF, etc. L’image de sortie est un format de fichier vectoriel SVG.

Pour vectoriser une image avec Aspose.SVG, vous devez suivre quelques étapes:

1. Initialisez une instance de la classe ImageVectorizer. Utilisez l’un des constructeurs ImageVectorizer() et spécifiez les propriétés de configuration.
2. Vectorisez l’image raster à partir du fichier spécifié. Utilisez la méthode Vectorize() qui renvoie un SVGDocument.
3. Enregistrez le SVGDocument (image vectorisée) en tant que fichier SVG.

Voici un exemple C# de la façon de vectoriser une image PNG à l’aide de l’API Aspose.SVG.

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

	var vectorizer = new ImageVectorizer
        {
            Configuration =
            {
                PathBuilder = new SplinePathBuilder
                {
                    TraceSmoother =   new ImageTraceSmoother(2),
                    TraceSimplifier = new ImageTraceSimplifier(0.1f),
                },
                ColorsLimit = 2
            }
        };

        using var document = vectorizer.Vectorize(Path.Combine(DataDir, "png-to-svg.png"));
        
        document.Save(Path.Combine(OutputDir, "png-to-svg.svg"));

Vous pouvez afficher le fichier source et le résultat final en suivant les liens – png-to-svg.png, png-to-svg.svg.

Vous trouverez la description et les exemples C# des options de vectorisation applicables dans l’article Exemples de vectorisation d’image.

Exemple d’implémentation d’IImageTraceSimplifier

L’espace de noms ImageVectorization comprend les interfaces IImageTraceSimplifier, IImageTraceSmoother et IPathBuilder pour réaliser n’importe laquelle de vos approches et algorithmes. Considérons l’implémentation de IImageTraceSimplifier basée sur l’algorithme Viswalingam :

	struct Point3
    {
        public float X { get; set; }
        public float Y { get; set; }
        public float? Z { get; set; }
        public Point3(float x, float y, float? z)
        {
            X = x;
            Y = y;
            Z = z;
        }
    }

    internal class Visvalingam: IImageTraceSimplifier
    {
        Point3[] line;
        List<int> indizes;
        bool enriched;
        float tolerance;

        public Visvalingam(float tolerance)
        {
            this.tolerance = tolerance;
        }

        // Calculate the area of one triangle
        private float GetTriangleArea(Point3 a, Point3 b, Point3 c)
		{
            return Math.Abs((a.X * (b.Y - c.Y) + b.X * (c.Y - a.Y) + c.X * (a.Y - b.Y)) / 2f);
        }

        // Add the area of the triangle to each point
        private float EnrichPoints()
		{
            var minArea = float.PositiveInfinity;

            for (var i = 1; i < indizes.Count() - 1; i++)
            {
                var @this = indizes[i];
                var prev = indizes[i - 1];
                var next = indizes[i + 1];
				
                var area = GetTriangleArea(line[prev], line[@this], line[next]);

                // Reset minim value for area, if current is smaller than all previous
                if (area < minArea)

                    minArea = area;

                // Save the area of the triangle as 3rd coordinate
                // Replace if it does exist already
                line[@this].Z = area;
            }
            return minArea;
        }

        // Check for the smallest triangles and remove corresponding points from the index
        private void RemoveSmallestAreaIndex(float minArea)
        {
            var newIndizes = new List<int>();
            newIndizes.Add(indizes[0]);
			
            for (var i = 1; i < indizes.Count - 1; i++)
            {
                var index = indizes[i];

                if (line[index].Z > minArea)

                    newIndizes.Add(index);
            }

            newIndizes.Add(indizes[indizes.Count - 1]);
            indizes = newIndizes;

            // Return newIndizes
        }

        // Do Visvalingam-Calculations until only start-& endpoint are left
        private void EnrichLineString()
        {
            while (indizes.Count > 2)

                RemoveSmallestAreaIndex(EnrichPoints());

            enriched = true;
        }

        // Simplify a linestring corresponding to a given tolerance (depends on projection of data)

        public IEnumerable<PointF> Simplify(IEnumerable<PointF> trace)
        {
            line = trace.Select(pt => new Point3(pt.X, pt.Y, null)).ToArray();
            indizes = line.Select((v, i) => i).ToList();
            enriched = false;

            // It is enough to enrich the line once
            if (enriched == false)
			
                EnrichLineString();

            // Build the new line
            return line.Where(p => p.Z != null && (p.Z > tolerance) || p.Z == null)

                .Select(p => new PointF(p.X, p.Y));
        }
    }

Vous pouvez télécharger les exemples C# complets et les fichiers de données à partir de GitHub. À propos du téléchargement depuis GitHub et de l’exécution d’exemples, vous le découvrirez dans la section Comment exécuter les exemples.