Le rendu des œuvres Adobe Illustrator (AI) sur un serveur est plus difficile qu’il n’y paraît, et l’ombrage basé sur des fonctions Type 1 est l’une des fonctionnalités qui posent problème à de nombreux moteurs de rendu. Si votre pipeline génère des miniatures, des aperçus web ou des épreuves d’impression à partir de fichiers AI, vous avez besoin que cet ombrage soit rendu correctement, et non remplacé par un remplissage uni. Aspose.PSD for .NET vous permet de convertir des fichiers AI contenant un ombrage Type 1 en PNG en C# avec quelques lignes de code et sans installation d’Adobe Illustrator. Ce tutoriel vous guide à travers l’installation du SDK, le chargement du fichier AI, la configuration de PngOptions, l’exportation de documents multi‑pages et la gestion des erreurs en production.

Pourquoi convertir le type d’ombrage AI 1 en PNG

Les fichiers modernes d’IA stockent leurs œuvres dans une structure compatible PDF, et le PDF définit plusieurs types de dégradés pour des transitions de couleur fluides. Type 2 (axial) et Type 3 (radial) décrivent des gradients linéaires et circulaires. Le dégradé de type 1 est basé sur une fonction : la couleur à chaque point est calculée par une fonction mathématique de ses coordonnées x et y. Cela le rend très flexible, mais cela signifie également que le moteur de rendu doit évaluer la fonction sur toute la zone dégradée.

Lorsqu’un moteur de rendu n’implémente pas le dégradé basé sur des fonctions, la zone ombrée est généralement ignorée ou peinte avec une couleur unique, et l’image exportée ne correspond plus à la conception originale. Aspose.PSD for .NET évalue le dégradé de type 1 en interne pendant le rendu, de sorte que le PNG que vous enregistrez reflète l’œuvre telle qu’elle a été conçue.

Avec cette capacité, les développeurs .NET peuvent :

  • Générez des miniatures et des aperçus précis pour les systèmes de gestion d’actifs numériques (DAM).
  • Publiez des versions PNG des illustrations Illustrator sur les sites Web et dans les applications qui ne peuvent pas afficher les fichiers AI.
  • Créez des pipelines de conversion par lots automatisés côté serveur qui s’exécutent sous Windows, Linux ou dans des conteneurs.

Utilisation d’Aspose.PSD pour convertir le shading de type AI 1

Aspose.PSD for .NET est une bibliothèque C# pour créer, modifier et convertir des fichiers Photoshop (PSD, PSB) ainsi que pour charger et exporter des fichiers Adobe Illustrator (AI). Elle fonctionne sans Adobe Photoshop ou Illustrator et est distribuée sous forme de package NuGet.

Les classes utilisées dans ce tutoriel sont :

  • Image (namespace Aspose.PSD) : le point d’entrée pour charger tout fichier pris en charge via Image.Load.
  • AiImage (namespace Aspose.PSD.FileFormats.Ai) : représente un document Illustrator chargé et expose des membres tels que PageCount et ActivePageIndex.
  • PngOptions (namespace Aspose.PSD.ImageOptions) : contrôle les paramètres d’exportation PNG tels que ColorType et CompressionLevel.
  • PngColorType (namespace Aspose.PSD.FileFormats.Png) : sélectionne le format de pixel PNG.

Installation

Installez le package depuis la console du Gestionnaire de packages :

Install-Package Aspose.PSD

Ou avec le CLI .NET:

dotnet add package AspAspose.PSD

Vous pouvez en savoir plus sur la page produit Aspose.PSD for .NET, dans la documentation développeur, et dans la référence API.

1. Configurez votre projet .NET

Créez une application console pour héberger le code de conversion. Les exemples ci-dessous utilisent des instructions de niveau supérieur et le pattern matching de C# 9, donc ciblez .NET 6 ou version ultérieure.

  1. Créez un nouveau projet à partir de la ligne de commande ou dans Visual Studio :
dotnet new console -n AiShadingConversion
cd AiShadingConversion
  1. Ajoutez le package Aspose.PSD for .NET en utilisant l’une des commandes d’installation montrées ci‑above.
  2. Ouvrez Program.cs et ajoutez les directives using requises en haut :
using System;
using System.IO;
using Aspose.PSD;
using Aspose.PSD.CoreExceptions;
using Aspose.PSD.FileFormats.Ai;
using Aspose.PSD.FileFormats.Png;
using Aspose.PSD.ImageOptions;

Aspose.PSD fournit la classe Image, et Aspose.PSD.FileFormats.Ai contient AiImage. PngOptions se trouve dans Aspose.PSD.ImageOptions, tandis que Aspose.PSD.FileFormats.Png fournit l’énumération PngColorType. Aspose.PSD.CoreExceptions contient ImageLoadException, que vous utiliserez pour la gestion des erreurs.

2. Charger un fichier AI contenant un ombrage de type 1

Image.Load détecte automatiquement le format du fichier. Lorsque la source est un document Illustrator, l’objet retourné est un AiImage. Vérifier le type avec le pattern matching est plus sûr qu’un cast direct, car un cast direct lève une InvalidCastException si quelqu’un passe un PSD ou un autre format pris en charge.

Ce que fait le code :

  • Construit le chemin complet vers le fichier AI source.
  • Charge le fichier avec Image.Load.
  • Confirme que le résultat est un AiImage et affiche sa taille ainsi que le nombre de pages.
string baseFolder = @"C:\Images";
string sourceFile = Path.Combine(baseFolder, "shadingType1.ai");

using (Image image = Image.Load(sourceFile))
{
    if (image is not AiImage aiImage)
    {
        Console.WriteLine("The source file is not an Adobe Illustrator document.");
        return;
    }

Console.WriteLine($"Loaded AI file: {aiImage.Width} x {aiImage.Height} px, pages: {aiImage.PageCount}");
}

Le bloc using libère l’image et libère ses ressources dès que vous avez fini de l’utiliser. Aucun paramétrage spécifique à l’ombrage n’est requis : l’ombrage de type 1 fait partie du contenu du document et est géré par le moteur de rendu lors de l’enregistrement.

3. Enregistrer l’image au format PNG

L’exportation au format PNG nécessite un seul appel à Save, qui accepte le chemin de sortie et une instance de PngOptions. Le réglage de ColorType sur PngColorType.TruecolorWithAlpha écrit une image RGBA 32 bits afin que toute transparence générée par le moteur de rendu soit conservée, et CompressionLevel (0 à 9) échange la vitesse d’encodage contre la taille du fichier.

Ce que fait le code :

  • Crée le dossier de sortie s’il n’existe pas.
  • Charge le fichier AI en tant que AiImage.
  • Configure PngOptions et enregistre le rendu de l’œuvre, y compris l’ombrage Type 1, au format PNG.
string baseFolder = @"C:\Images";
string outputFolder = @"C:\Converted";
string sourceFile = Path.Combine(baseFolder, "shadingType1.ai");
string outputFile = Path.Combine(outputFolder, "shadingType1.png");

Directory.CreateDirectory(outputFolder);

using (var aiImage = (AiImage)Image.Load(sourceFile))
{
    var pngOptions = new PngOptions
    {
        ColorType = PngColorType.TruecolorWithAlpha,
        CompressionLevel = 6 // 0 = store (fastest), 9 = maximum compression
    };

aiImage.Save(outputFile, pngOptions);
    Console.WriteLine($"PNG saved to {outputFile}");
}

Ouvrez shadingType1.png dans n’importe quel visualiseur d’images et comparez-le avec l’œuvre originale pour confirmer que les zones ombrées s’affichent comme prévu.

Exemple complet : Convertir le shading AI Type 1 en PNG en C#

Le Program.cs suivant combine tout en une application console prête pour la production. Il valide l’entrée, exporte chaque page d’un fichier AI multi‑pages et gère les erreurs de chargement.

using System;
using System.IO;
using Aspose.PSD;
using Aspose.PSD.CoreExceptions;
using Aspose.PSD.FileFormats.Ai;
using Aspose.PSD.FileFormats.Png;
using Aspose.PSD.ImageOptions;

// Optional: apply a license to remove the evaluation watermark.
// var license = new License();
// license.SetLicense("Aspose.PSD.NET.lic");

string sourceFile = @"C:\Images\shadingType1.ai";
string outputFolder = @"C:\Converted";

if (!File.Exists(sourceFile))
{
    Console.WriteLine($"Source file not found: {sourceFile}");
    return;
}

Directory.CreateDirectory(outputFolder);

var pngOptions = new PngOptions
{
    ColorType = PngColorType.TruecolorWithAlpha,
    CompressionLevel = 6
};

try
{
    using (Image image = Image.Load(sourceFile))
    {
        if (image is not AiImage aiImage)
        {
            Console.WriteLine("The source file is not an Adobe Illustrator document.");
            return;
        }

string baseName = Path.GetFileNameWithoutExtension(sourceFile);

// Legacy AI files report PageCount = 0, so treat them as a single page.
        if (aiImage.PageCount <= 1)
        {
            string outputFile = Path.Combine(outputFolder, $"{baseName}.png");
            aiImage.Save(outputFile, pngOptions);
            Console.WriteLine($"Saved {outputFile}");
        }
        else
        {
            for (int i = 0; i < aiImage.PageCount; i++)
            {
                aiImage.ActivePageIndex = i;
                string outputFile = Path.Combine(outputFolder, $"{baseName}_page{i + 1}.png");
                aiImage.Save(outputFile, pngOptions);
                Console.WriteLine($"Saved {outputFile}");
            }
        }
    }
}
catch (ImageLoadException ex)
{
    Console.WriteLine($"Could not load the AI file: {ex.Message}");
}
catch (Exception ex)
{
    Console.WriteLine($"Conversion failed: {ex.Message}");
}

4. Conseils, pièges courants et considérations de performance

Exporter les fichiers AI multi‑pages page par page

Les documents Illustrator peuvent contenir plusieurs pages (plans de travail). AiImage.PageCount renvoie le nombre de pages, et ActivePageIndex sélectionne la page que Save rend. Définissez l’index, enregistrez, puis répétez, comme le montre l’exemple complet. Notez que AiImage.Layers renvoie des objets AiLayerSection qui décrivent la structure du document ; ils ne sont pas des images séparées, donc utilisez les pages plutôt que les calques lorsque vous avez besoin d’un PNG par plan de travail.

Utilisez la correspondance de motifs au lieu de conversions aveugles

Un cast tel que (AiImage)Image.Load(path) est correct lorsque vous contrôlez l’entrée. Dans les gestionnaires de téléchargement ou les travaux par lots, privilégiez image is AiImage aiImage afin que les formats inattendus soient signalés clairement au lieu de lever InvalidCastException.

Gérer la mémoire lors des conversions par lots

Le rendu d’illustrations volumineuses ou complexes, en particulier avec un ombrage basé sur des fonctions, est intensif en CPU et en mémoire. Enveloppez toujours chaque image chargée dans un bloc using, traitez les fichiers un par un (ou avec un petit degré de parallélisme limité), et réutilisez une seule instance PngOptions pour tous les fichiers.

Préserver la transparence

Utilisez PngColorType.TruecolorWithAlpha lorsque le PNG sera placé sur d’autres contenus, par exemple sur une page web ou dans un outil de conception. Si vous n’avez pas besoin d’un canal alpha, une sortie truecolor sans alpha produit des fichiers plus petits.

Gérer les erreurs explicitement

Vérifiez que le fichier d’entrée existe avant de le charger, et capturez ImageLoadException (espace de noms Aspose.PSD.CoreExceptions) pour les fichiers corrompus ou qui ne peuvent pas être analysés. Enregistrez le nom du fichier ainsi que le message d’exception afin que les éléments échoués dans un lot soient faciles à réessayer.

Maintenez Aspose.PSD à jour

Le rendu IA s’améliore régulièrement d’une version à l’autre, incluant des correctifs pour l’ombrage, les masques souples et les images intégrées. Si un fichier rend différemment de ce qui est attendu, mettez à jour vers la dernière version du package avant de poursuivre le dépannage.

Obtenez une licence gratuite

Sans licence, Aspose.PSD for .NET s’exécute en mode d’évaluation et ajoute un filigrane aux images exportées. Demandez une licence temporaire gratuite pour tester l’API complète pendant 30 jours, puis appliquez‑la avant le premier appel à Image.Load.

var license = new License();
license.SetLicense("Aspose.PSD.NET.lic");

Ressources supplémentaires gratuites

Conclusion

La conversion de fichiers AI avec ombrage basé sur des fonctions de type 1 en PNG en C# est simple avec Aspose.PSD for .NET. Installez le package NuGet, chargez le fichier avec Image.Load, configurez PngOptions et appelez Save : la bibliothèque évalue l’ombrage lors du rendu, de sorte que votre PNG correspond à l’œuvre originale sans Adobe Illustrator ni outils externes. Avec une exportation page par page, des vérifications de type sécurisées et une gestion explicite des erreurs, le même code passe d’un aperçu unique à des pipelines de conversion côté serveur à haut volume.

FAQ

1. Ai‑je besoin d’une licence pour convertir le shading AI Type 1 en PNG ?
Aucune licence n’est nécessaire pour l’essayer, mais sans licence Aspose.PSD s’exécute en mode d’évaluation, ce qui ajoute un filigrane à la sortie. Vous pouvez demander une licence temporaire gratuite de 30 jours pour évaluer sans restrictions. Une licence achetée est requise pour une utilisation en production.

2. Comment convertir un fichier AI multi-pages en PNG en C# ? Lisez la propriété AiImage.PageCount, puis définissez ActivePageIndex sur chaque indice de page et appelez Save avec un chemin de sortie distinct. Les fichiers AI anciens indiquent un PageCount de 0, traitez‑les donc comme une seule page.

3. Que se passe-t-il si le fichier AI ne contient pas d’ombrage de type 1 ? Rien ne change dans votre code. Aspose.PSD rend tout ce que le fichier contient, y compris d’autres types de dégradés, des chemins et des images intégrées, et enregistre le résultat au format PNG.

4. Y a-t-il une perte de qualité lors de l’exportation d’AI en PNG ?
PNG est un format sans perte, donc les pixels produits par le rendu sont stockés sans artefacts de compression. La taille de sortie suit le Width et le Height rapportés par le AiImage chargé.

5. Quelles versions .NET Aspose.PSD for .NET prend-elle en charge ?
Aspose.PSD for .NET prend en charge à la fois le .NET Framework et le .NET moderne, et des builds dédiés pour .NET 8 et .NET 9 sont disponibles depuis la version 25.4. Consultez l’onglet Frameworks du package Aspose.PSD sur NuGet pour connaître les cibles exactes de la version que vous installez.

6. Comment puis‑je contrôler le niveau de compression PNG ? Définissez PngOptions.CompressionLevel sur une valeur comprise entre 0 (stockage, le plus rapide) et 9 (compression maximale, fichier le plus petit) avant d’appeler Save. La compression est sans perte à chaque niveau, elle n’affecte donc que la taille du fichier et le temps d’encodage.

En savoir plus