ImageSharp C# (.NET) : méthodes, exemples, installation | PythonLib

ImageSharp pour C# (.NET) : guide complet avec exemples

1. Qu'est-ce que ImageSharp et pourquoi l'utiliser ?

ImageSharp est une bibliothèque de traitement d'images puissante, entièrement gérée et multiplateforme, écrite en C# pour l'écosystème .NET. Elle fait partie de la famille de bibliothèques SixLabors et offre aux développeurs une API propre, sécurisée et haute performance pour travailler avec des images, sans nécessiter de dépendances natives externes (telles que ImageMagick, SkiaSharp ou GDI+). Cela signifie qu'ImageSharp fonctionne aussi bien sur Windows, Linux et macOS, ce qui en fait un choix idéal pour les applications web (ASP.NET Core), les microservices, les utilitaires console et les applications mobiles (via Xamarin/MAUI).

Pourquoi utiliser ImageSharp ? Dans le développement moderne, le traitement d'images est omniprésent : de la création de miniatures pour les galeries et du redimensionnement des avatars utilisateurs à l'ajout de filigranes, l'application de filtres et la conversion de formats. ImageSharp propose tout cela "prêt à l'emploi" avec un accent sur la performance et la sécurité. Contrairement à l'ancien System.Drawing, lié à Windows et sujet à des problèmes de threads, ImageSharp est thread-safe et entièrement multiplateforme. Elle est également activement soutenue par la communauté et dispose d'une documentation détaillée.

Les fonctionnalités clés de la bibliothèque incluent : le chargement et l'enregistrement d'images dans les formats populaires (JPEG, PNG, BMP, GIF, WebP, TIFF), le redimensionnement, le recadrage, la rotation, le retournement, l'ajout de texte et de formes, l'application de matrices de couleurs, de filtres (flou, netteté, sépia, noir et blanc), la gestion des données EXIF, l'animation GIF et bien plus encore. ImageSharp est construite autour du concept d'Image en tant que conteneur de données pixel et fournit une API flexible via des méthodes d'extension.

2. Installation

L'installation d'ImageSharp dans un projet .NET se fait via le gestionnaire de packages NuGet. Exécutez l'une des commandes suivantes dans le terminal ou la console du gestionnaire de packages :

// Via .NET CLI (recommandé)
dotnet add package SixLabors.ImageSharp

// Via Package Manager Console
Install-Package SixLabors.ImageSharp

// Via NuGet Package Manager dans Visual Studio/Rider
// Recherchez "SixLabors.ImageSharp" et installez la dernière version stable

Après l'installation, ajoutez la directive using au début de votre fichier :

using SixLabors.ImageSharp;
using SixLabors.ImageSharp.Processing;
using SixLabors.ImageSharp.Formats.Jpeg;
// ... autres directives selon vos besoins

Note : Assurez-vous d'utiliser la dernière version stable pour bénéficier des dernières fonctionnalités et corrections de bugs. Consultez la page NuGet de SixLabors.ImageSharp pour les mises à jour.

3. Chargement et enregistrement d'images

La première étape avec ImageSharp consiste à charger une image depuis un fichier, un flux ou une URL. Voici comment procéder :

// Chargement depuis un fichier
using (Image image = Image.Load("chemin/vers/image.jpg"))
{
    // Traitement de l'image...
    
    // Enregistrement dans un autre format
    image.Save("chemin/vers/image.png"); // Sauvegarde automatique au format PNG
}

// Chargement depuis un flux (Stream)
using (FileStream stream = File.OpenRead("photo.jpg"))
using (Image image = Image.Load(stream))
{
    // Traitement...
}

// Enregistrement avec des options spécifiques (qualité JPEG, etc.)
var encoder = new JpegEncoder { Quality = 85 };
image.Save("sortie.jpg", encoder);

ImageSharp détecte automatiquement le format de l'image chargée (JPEG, PNG, GIF, BMP, etc.) et gère la conversion lors de l'enregistrement. Vous pouvez également spécifier explicitement l'encodeur pour un contrôle précis.

4. Redimensionnement d'image

Le redimensionnement est l'une des opérations les plus courantes. ImageSharp offre plusieurs modes de redimensionnement via la méthode Resize :

using (Image image = Image.Load("input.jpg"))
{
    // Redimensionnement simple avec des dimensions exactes
    image.Mutate(x => x.Resize(800, 600));
    
    // Redimensionnement en conservant le ratio (mode "pad")
    image.Mutate(x => x.Resize(new ResizeOptions
    {
        Size = new Size(300, 300),
        Mode = ResizeMode.Pad, // Ajoute des bandes si nécessaire
        Position = AnchorPositionMode.Center
    }));
    
    // Redimensionnement avec recadrage automatique (mode "crop")
    image.Mutate(x => x.Resize(new ResizeOptions
    {
        Size = new Size(200, 200),
        Mode = ResizeMode.Crop // Recadre pour remplir exactement
    }));
    
    // Redimensionnement avec un facteur d'échelle
    image.Mutate(x => x.Resize((int)(image.Width * 0.5), (int)(image.Height * 0.5)));
    
    image.Save("output_resized.jpg");
}

Les modes de redimensionnement disponibles incluent : Stretch (étire sans conserver le ratio), BoxPad (ajuste avec des bandes), Pad (similaire à BoxPad mais plus précis), Crop (recadre pour remplir), Max (réduit pour tenir dans les dimensions données) et Min (garantit que l'image couvre au moins les dimensions données).

5. Recadrage (Crop)

Le recadrage permet d'extraire une région rectangulaire spécifique de l'image :

using (Image image = Image.Load("input.jpg"))
{
    // Recadrage avec un rectangle
    Rectangle cropArea = new Rectangle(100, 50, 400, 300);
    image.Mutate(x => x.Crop(cropArea));
    
    // Recadrage centré automatique
    image.Mutate(x => x.Crop(300, 300)); // Recadre au centre
    
    image.Save("output_cropped.jpg");
}

6. Rotation et retournement

ImageSharp permet de faire pivoter et de retourner les images facilement :

using (Image image = Image.Load("input.jpg"))
{
    // Rotation de 90 degrés dans le sens horaire
    image.Mutate(x => x.Rotate(RotateMode.Rotate90));
    
    // Rotation de 180 degrés
    image.Mutate(x => x.Rotate(RotateMode.Rotate180));
    
    // Rotation avec un angle personnalisé (en degrés)
    image.Mutate(x => x.Rotate(45)); // Rotation de 45 degrés
    
    // Retournement horizontal (miroir)
    image.Mutate(x => x.Flip(FlipMode.Horizontal));
    
    // Retournement vertical
    image.Mutate(x => x.Flip(FlipMode.Vertical));
    
    image.Save("output_rotated.jpg");
}

7. Application de filtres

ImageSharp propose une variété de filtres pour modifier l'apparence de l'image :

using (Image image = Image.Load("input.jpg"))
{
    // Conversion en noir et blanc (nuances de gris)
    image.Mutate(x => x.Grayscale());
    
    // Application d'un filtre sépia
    image.Mutate(x => x.Sepia());
    
    // Flou gaussien (intensité : 3 pixels)
    image.Mutate(x => x.GaussianBlur(3));
    
    // Netteté (intensité : 1.5)
    image.Mutate(x => x.GaussianSharpen(1.5f));
    
    // Inversion des couleurs (négatif)
    image.Mutate(x => x.Invert());
    
    // Ajustement de la luminosité (valeur entre -1 et 1)
    image.Mutate(x => x.Brightness(0.2f)); // Augmente la luminosité de 20%
    
    // Ajustement du contraste (valeur entre -1 et 1)
    image.Mutate(x => x.Contrast(0.3f)); // Augmente le contraste de 30%
    
    image.Save("output_filtered.jpg");
}

8. Ajout de texte et de formes

Vous pouvez superposer du texte et des formes géométriques sur vos images :

using (Image image = Image.Load("input.jpg"))
{
    // Ajout de texte
    Font font = SystemFonts.CreateFont("Arial", 48, FontStyle.Bold);
    image.Mutate(x => x.DrawText("Hello, ImageSharp!", font, Color.White, new PointF(50, 50)));
    
    // Ajout d'un rectangle rempli
    image.Mutate(x => x.DrawPolygon(Color.Red, 5, new PointF(100, 100), new PointF(200, 100), new PointF(200, 200), new PointF(100, 200)));
    
    // Ajout d'un cercle
    image.Mutate(x => x.DrawCircle(Color.Blue, 3, new PointF(300, 300), 50));
    
    // Ajout d'une ligne
    image.Mutate(x => x.DrawLine(Color.Green, 5, new PointF(0, 0), new PointF(400, 400)));
    
    image.Save("output_text_shapes.jpg");
}

9. Gestion des formats et de la qualité

ImageSharp prend en charge de nombreux formats d'image et permet de contrôler la qualité de sortie :

using (Image image = Image.Load("input.png"))
{
    // Enregistrement en JPEG avec qualité 75%
    var jpegEncoder = new JpegEncoder { Quality = 75 };
    image.Save("output.jpg", jpegEncoder);
    
    // Enregistrement en PNG avec compression maximale
    var pngEncoder = new PngEncoder { CompressionLevel = PngCompressionLevel.BestCompression };
    image.Save("output.png", pngEncoder);
    
    // Enregistrement en GIF
    var gifEncoder = new GifEncoder();
    image.Save("output.gif", gifEncoder);
    
    // Enregistrement en WebP (nécessite le package SixLabors.ImageSharp.WebP)
    // var webpEncoder = new WebPEncoder { Quality = 80 };
    // image.Save("output.webp", webpEncoder);
    
    // Enregistrement en TIFF
    var tiffEncoder = new TiffEncoder { PhotometricInterpretation = TiffPhotometricInterpretation.Rgb };
    image.Save("output.tiff", tiffEncoder);
}

10. Traitement par lots et performances

Pour traiter plusieurs images efficacement, utilisez la parallélisation et les flux :

// Traitement par lots avec Parallel.ForEach
string[] files = Directory.GetFiles("images/", "*.jpg");
Parallel.ForEach(files, file =>
{
    using (Image image = Image.Load(file))
    {
        image.Mutate(x => x.Resize(800, 600));
        image.Save(Path.Combine("output/", Path.GetFileName(file)));
    }
});

// Utilisation de Configuration pour optimiser les performances
var configuration = Configuration.Default.Clone();
configuration.MaxDegreeOfParallelism = Environment.ProcessorCount; // Utilise tous les cœurs

using (Image image = Image.Load("input.jpg", configuration))
{
    image.Mutate(x => x.Resize(800, 600));
    image.Save("output.jpg");
}

11. Gestion des erreurs et bonnes pratiques

Attention : Toujours encapsuler les opérations ImageSharp dans des blocs using pour libérer les ressources mémoire correctement. Les images peuvent consommer beaucoup de RAM, surtout en haute résolution.

try
{
    using (Image image = Image.Load("input.jpg"))
    {
        // Traitement...
    }
}
catch (InvalidImageContentException ex)
{
    Console.WriteLine($"Format d'image invalide : {ex.Message}");
}
catch (UnknownImageFormatException ex)
{
    Console.WriteLine($"Format d'image non supporté : {ex.Message}");
}
catch (Exception ex)
{
    Console.WriteLine($"Erreur générale : {ex.Message}");
}

12. Conclusion

ImageSharp est une bibliothèque de traitement d'images moderne, puissante et multiplateforme pour l'écosystème .NET. Elle offre une alternative robuste à System.Drawing et à d'autres solutions natives, avec une API intuitive et des performances élevées. Que vous développiez une application web ASP.NET Core, un microservice, une application de bureau ou mobile, ImageSharp vous fournira tous les outils nécessaires pour manipuler des images de manière professionnelle.

Pour aller plus loin, explorez la documentation officielle de SixLabors.ImageSharp et les exemples avancés sur GitHub. N'hésitez pas à expérimenter avec les différentes fonctionnalités pour découvrir tout le potentiel de cette bibliothèque exceptionnelle.