Vectorisation d'images – Code Python Aspose.SVG

Cet article vous présente les bases de la vectorisation d’images à l’aide de la bibliothèque Python Aspose.SVG. L’article passe en revue plusieurs exemples Python démontrant la fonctionnalité de ImageVectorization et l’impact des propriétés de configuration sur le résultat de la vectorisation.

Image raster ou graphique vectoriel

Il existe deux principaux types d’images: vectorielles et raster. Le choix entre eux dépend du cas d’utilisation spécifique. Un bitmap, également appelé image raster, est un tableau bidimensionnel qui mappe les couleurs sur des pixels individuels. Les images raster sont généralement des fichiers beaucoup plus volumineux que les images vectorielles et fonctionnent bien pour les photographies ou les images avec des dégradés de couleurs. Cependant, un inconvénient majeur des images raster est la perte de qualité lors de la mise à l’échelle, entraînant une pixellisation et un flou.

Les graphiques vectoriels, quant à eux, sont constitués de formes géométriques telles que des courbes de Bézier, des splines et des lignes. Ces formes sont déterminées par des équations mathématiques, permettant aux images vectorielles d’être mises à l’échelle à l’infini sans perdre en qualité. Cela rend les graphiques vectoriels idéaux pour les logos, les icônes, les mises en page, les cartes, les graphiques, les dessins au trait et les illustrations. Elles génèrent souvent des fichiers de plus petite taille que les images raster, en particulier pour les projets plus simples.

Vectorisation des images

La vectorisation d’image est le processus de conversion d’une image raster en graphiques vectoriels. Cela implique de convertir les informations sur les pixels d’une image raster en une série de courbes et de formes mathématiques. Les avantages des images vectorielles incluent leur évolutivité et leur taille de fichier généralement plus petite pour certains types d’images. Cependant, les images vectorielles peuvent être moins efficaces pour les images ou les photographies très détaillées qui nécessitent des variations de couleurs et des dégradés complexes.

Aspose.SVG for Python via .NET fournit une solution robuste pour vectoriser des images via l’espace de noms ImageVectorization. Cela permet aux utilisateurs de convertir divers formats d’images raster tels que JPG, PNG, BMP, TIFF et GIF au format de fichier vectoriel SVG. Le processus de vectorisation peut être affiné à l’aide de propriétés de configuration telles que path_builder, colors_limit, error_threshold, trace_smoother, max_iterations, stencil, etc. qui affectent la qualité et le détail des graphiques vectoriels résultants. Cette technologie permet un contrôle précis du processus de vectorisation, garantissant une haute qualité et une évolutivité des images vectorielles.

Exemple Python 1. Vectorisation d’image

Pour vectoriser une image avec la bibliothèque Python Aspose.SVG, vous devez suivre quelques étapes:

1. Créez une instance de la classe BezierPathBuilder pour définir la stratégie de création de chemin. Ici, vous pouvez définir les propriétés de BezierPathBuilder, telles que trace_smoother, error_threshold et max_iterations.
2. Créez une instance de la classe ImageVectorizer. ImageVectorizer est la classe principale utilisée pour convertir des images en graphiques vectoriels.
   • Attribuez la configuration path_builder (définie précédemment) à l’objet vectorizer. Cela signifie que le vectoriseur utilisera les paramètres spécifiés dans path_builder pour la création et l’optimisation du chemin.
   • Définissez les propriétés colors_limit et line_width de la classe ImageVectorizerConfiguration.
3. Utilisez la méthode vectorize() pour vectoriser une image à partir du fichier spécifié.
4. Enregistrez l’image vectorisée sous forme de fichier SVG en utilisant la méthode save sur la classe SVGDocument.

import os
from aspose.svg.imagevectorization import ImageVectorizer, ImageTraceSmoother, BezierPathBuilder

# Setup directories
input_folder = "data/"
output_folder = "output/"
src_file = "fish.png"
output_file = "fish-vectorized.svg"
if not os.path.exists(output_folder):
    os.makedirs(output_folder)

# Configuration for vectorization
path_builder = BezierPathBuilder()
path_builder.trace_smoother = ImageTraceSmoother(3)
path_builder.error_threshold = 10.0
path_builder.max_iterations = 20

vectorizer = ImageVectorizer()
vectorizer.configuration.path_builder = path_builder
vectorizer.configuration.colors_limit = 3
vectorizer.configuration.line_width = 1.5

# Vectorize an image
with vectorizer.vectorize(os.path.join(input_folder, src_file)) as document:
    output_file = os.path.join(output_folder, output_file)
    document.save(output_file)

Cet exemple de code vous permet de vectoriser une image raster couleur en une image vectorielle. Les options de vectorisation sont sélectionnées de manière à obtenir le résultat souhaité illustré à la figure (b). Nous voulions une image simplifiée en trois couleurs de l’original. La figure suivante montre l’image source (a) et l’image vectorisée à l’aide de l’extrait de code Python ci-dessus (b).

Options de vectorisation

Vous pouvez appliquer des paramètres personnalisés pour obtenir le meilleur résultat de la vectorisation de l’image. Vous trouverez ci-dessous quelques-uns des principaux paramètres que vous pouvez contrôler, ainsi que leurs valeurs par défaut:

• tolérance – La valeur de la tolérance détermine la tolérance d’erreur maximale autorisée pour qu’un point soit éliminé de la trace. Elle doit être comprise entre 0 et 4. La valeur par défaut est 0,3.
• trace_smoother – Cette propriété est utilisée pour lisser les chemins générés lors du processus de vectorisation. Il peut prendre un paramètre (severity) qui définit le degré de lissage appliqué.
• error_threshold – Cette propriété définit l’écart maximal des points par rapport à la courbe ajustée. Par défaut, c’est 30.
• max_iterations – définit un nombre d’itérations pour la méthode d’approximation des moindres carrés. Par défaut, c’est 30.
• background_color – la valeur par défaut est le blanc transparent.
• colors_limit – définit le nombre maximum de couleurs utilisées pour quantifier une image. La valeur par défaut est 25.
• line_width – définit la largeur de la ligne. La valeur de ce paramètre est affectée par l’échelle graphique. La valeur par défaut est 1.
• image_size_limit – dimension maximale d’une image déterminée par la multiplication de la largeur et de la hauteur de l’image. La taille de l’image sera mise à l’échelle en fonction de cette propriété. La valeur par défaut est 1 800 000.

Exemple Python 2. Vectorisation de photos

Est-il possible de convertir une photo au format vectoriel pour qu’elle soit identique à la photo?

SVG n’est pas bien adapté pour dessiner des images photoréalistes. Les images vectorielles ne permettent pas encore de transitions de couleurs naturelles. Les graphiques vectoriels sont les meilleurs pour créer des logos, des illustrations et des dessins techniques. Ce n’est pas le format le plus approprié pour les images en tons continus avec des mélanges de couleurs ou pour retoucher des photographies. Cependant, la vectorisation des photos peut donner lieu à des effets artistiques impressionnants qui peuvent être intéressants et utiles.

Dans cette section, nous convertissons une photo au format vectoriel et essayons de choisir les options de vectorisation pour que le résultat soit identique à la photo:

import os
from aspose.svg.imagevectorization import ImageVectorizer, ImageTraceSmoother, BezierPathBuilder

# Setup directories
input_folder = "data/"
output_folder = "output/"
src_file = "lioness.jpg"
output_file = "lioness.svg"
if not os.path.exists(output_folder):
    os.makedirs(output_folder)

# Configuration for vectorization
path_builder = BezierPathBuilder()
path_builder.trace_smoother = ImageTraceSmoother(1)
path_builder.error_threshold = 30.0
path_builder.max_iterations = 30

vectorizer = ImageVectorizer()
vectorizer.configuration.path_builder = path_builder
vectorizer.configuration.colors_limit = 25
vectorizer.configuration.line_width = 1.5

# Vectorize a photo
with vectorizer.vectorize(os.path.join(input_folder, src_file)) as document:
    output_file = os.path.join(output_folder, output_file)
    document.save(output_file)

La figure montre la photo source (a), l’image vectorisée à l’aide de l’extrait de code Python (b).

Comme mentionné ci-dessus, SVG n’est pas le format le plus approprié pour les images à tons continus avec des mélanges de couleurs, etc. Le processus de vectorisation utilise la quantification des images couleur. Tous les petits points ou pixels de même couleur, on les remplace par des formes géométriques ou des courbes. La photo source (a) et le fichier SVG résultant (b), vous pouvez trouver et visualiser en détail en suivant les liens – lioness.jpg, lioness.svg.

Limites de la licence

Une version d’évaluation gratuite d’Aspose.SVG for Python via .NET fournit toutes les fonctionnalités de vectorisation d’images à l’exception des suivantes:

• Seules 4 couleurs dominantes seront utilisées pour quantifier une image.
• Seuls 50 % des nœuds du document SVG seront enregistrés lors de la sérialisation.

Si vous souhaitez essayer Aspose.SVG for Python via .NET sans limitations d’évaluation, demandez une licence temporaire de 30 jours. Pour plus d’informations, veuillez vous référer à Comment obtenir une licence temporaire?

La figure montre le résultat de la conversion photo en vecteur sans application de licence.

Voir aussi

• Dans l’article Vectorisation d’images – Workflow, vous trouverez une description du processus de vectorisation d’image - quantification des couleurs, redimensionnement, traçage de contours, etc.
• L’article Image Pochoir – Comment créer un pochoir en Python explique comment créer des pochoirs à partir d’images à l’aide d’Aspose.SVG for Python via .NET API.
• Vous pouvez essayer Vectoriseur d’images en ligne en temps réel! Cet outil propose diverses options pour prétraiter les bitmaps avant de les enregistrer au format SVG. Vous pouvez gérer de manière interactive le fichier SVG vectorisé en utilisant des contrôles liés aux options de vectorisation appropriées.

Aspose.SVG propose un Vectoriseur d’image en ligne gratuit conçu pour convertir des images bitmap telles que JPG, PNG, BMP, TIFF et GIF en graphiques vectoriels. Après la conversion, tous les éléments graphiques vectoriels sont enregistrés sous forme de fichiers SVG. Notre vectoriseur gratuit fonctionne sur n’importe quelle plateforme. Avec cette application, vous pouvez appliquer diverses options pour obtenir le résultat parfait. Gagnez du temps et découvrez les avantages des graphiques vectoriels avec notre vecteur d’image gratuit!