Dessiner des images raster et vectorielles

Que vous créiez un site Web, une application de bureau ou une application mobile, la capacité de manipuler et de dessiner sur des images est un aspect crucial lors du traitement et de l’édition d’images. Pour offrir aux développeurs des fonctionnalités de dessin avancées mais faciles à mettre en œuvre, nous introduisons Aspose.Imaging.Drawing, une API puissante conçue pour les applications C# .NET, offrant une gamme de fonctionnalités de dessin d’images.

Bibliothèque de dessins C# .NET

Aspose.Imaging.Drawing est une API robuste qui vous permet de traiter des images raster et vectorielles avec des techniques avancées de traitement d’image. Avec un accès natif aux octets, l’API garantit une vitesse de traitement élevée lors de la création ou de la manipulation d’images. À l’aide de l’API, vous pouvez dessiner des objets avec manipulation de pixels et chemin graphique et convertir des images d’un format à un autre. Aspose.Imaging.Drawing utilise Aspose.Drawing comme moteur graphique par défaut, qui est une bibliothèque graphique 2D multiplateforme qui offre un ensemble complet de fonctionnalités pour dessiner du texte, des géométries et des images sans aucune dépendance externe.

Vous pouvez télécharger et installer Aspose.Imaging.Drawing à partir de NuGet.

PM> NuGet\Install-Package Aspose.Imaging.Drawing

Jetons maintenant un coup d’œil à quelques fonctionnalités principales de cette API de dessin .NET et à leur utilisation à l’aide du code source.

Création de graphiques à l’aide de la bibliothèque de dessins .NET

Aspose.Imaging.Drawing vous permet de créer des images en dessinant différents objets tels que des cercles, des lignes, des triangles, des carrés et des ellipses. Non seulement les images raster, mais vous pouvez générer des images vectorielles à l’aide de l’API. Voyons comment dessiner des images raster et vectorielles en C# à l’aide de cette API de dessin .NET.

Dessiner une image raster

Vous trouverez ci-dessous les étapes pour dessiner une image raster à l’aide de l’API Aspose.Imaging.Drawing.

  • Tout d’abord, créez une image du format souhaité à l’aide de la méthode Image.Create().
  • Ensuite, créez un objet de classe Graphics et initialisez-le avec l’image que nous avons créée ci-dessus.
  • Effacez la surface de l’image à l’aide de la méthode Graphics.Clear.
  • Créez un nouveau stylo et initialisez-le avec la couleur souhaitée.
  • Dessinez une ellipse (ou tout autre objet graphique) à l’aide de la méthode Graphics.DrawEllipse().
  • Dessinez un polygone en utilisant la méthode Graphics.FillPolygon().
  • Enfin, enregistrez l’image à l’aide de la méthode Image.Save().

L’extrait de code suivant montre comment dessiner une image en C#.

string outputFolder = @"Output\";

// Créez une instance de BmpOptions et définissez ses différentes propriétés
BmpOptions imageOptions = new BmpOptions();
imageOptions.BitsPerPixel = 24;

// Créez une instance de FileCreateSource et attribuez-la à la propriété Source 
imageOptions.Source = new FileCreateSource(outputFolder + "result.bmp", false);

using (var image = Image.Create(imageOptions, 500, 500))
{
    var graphics = new Graphics(image);

    // Effacez la surface de l'image avec une couleur blanche et créez et initialisez un objet Pen avec une couleur bleue
    graphics.Clear(Color.White);
    var pen = new Pen(Color.Blue);

    // Dessinez une ellipse en définissant le rectangle englobant de largeur 150 et de hauteur 100. Dessinez également un polygone à l'aide de LinearGradientBrush.
    graphics.DrawEllipse(pen, new Rectangle(10, 10, 150, 100));

    using (var linearGradientBrush = new LinearGradientBrush(image.Bounds, Color.Red, Color.White, 45f))
    {
        graphics.FillPolygon(linearGradientBrush, new[] { new Point(200, 200), new Point(400, 200), new Point(250, 350) });
    }

    // Enregistrer l'image
    image.Save();
}

Dessiner une image vectorielle

Semblable aux images raster, vous pouvez dessiner des graphiques vectoriels, tels que SVG, en quelques étapes simples. Créons une image vectorielle à l’aide de notre bibliothèque de dessins C#.

  • Tout d’abord, créez un objet MemoryStream.
  • Ensuite, chargez une image SVG.
  • Pixellisez SVG en PNG et écrivez le résultat dans un flux.
  • Chargez une image PNG à partir du flux pour un dessin ultérieur.
  • Dessinez une image PNG sur une image SVG existante.
  • Enfin, enregistrez les résultats.

L’extrait de code suivant montre comment dessiner une image vectorielle en C#.

string templatesFolder = @"Templates\";
string outputFolder = @"Output\";

using (MemoryStream drawnImageStream = new MemoryStream())
{
    // Tout d’abord, rastérisez Svg en Png et écrivez le résultat dans un flux.
    using (SvgImage svgImage = (SvgImage)Image.Load(templatesFolder + "template.svg"))
    {
        SvgRasterizationOptions rasterizationOptions = new SvgRasterizationOptions();
        rasterizationOptions.PageSize = svgImage.Size;

        PngOptions saveOptions = new PngOptions();
        saveOptions.VectorRasterizationOptions = rasterizationOptions;

        svgImage.Save(drawnImageStream, saveOptions);

        // Chargez maintenant une image Png à partir du flux pour un dessin ultérieur.
        drawnImageStream.Seek(0, System.IO.SeekOrigin.Begin);
        using (RasterImage imageToDraw = (RasterImage)Image.Load(drawnImageStream))
        {
            // S'appuyant sur l'image Svg existante.
            Aspose.Imaging.FileFormats.Svg.Graphics.SvgGraphics2D graphics = new Aspose.Imaging.FileFormats.Svg.Graphics.SvgGraphics2D(svgImage);

            // Réduisez l'intégralité de l'image dessinée de 2 fois et dessinez-la au centre de la surface de dessin.
            int width = imageToDraw.Width / 2;
            int height = imageToDraw.Height / 2;
            Point origin = new Point((svgImage.Width - width) / 2, (svgImage.Height - height) / 2);
            Size size = new Size(width, height);

            graphics.DrawImage(imageToDraw, origin, size);

            // Enregistrer l'image du résultat
            using (SvgImage resultImage = graphics.EndRecording())
            {
                resultImage.Save(outputFolder + "vector_image.svg");
            }
        }
    }
}

Appliquer un masquage aux images

Le masquage dans l’édition d’images fait référence à la technique consistant à masquer ou à révéler sélectivement certaines parties d’une image. Cela implique la création d’un masque, qui est essentiellement une image en niveaux de gris qui définit la transparence ou l’opacité de chaque pixel de l’image originale. Le masquage d’image est largement pratiqué pour la reconnaissance et le diagnostic.

Aspose.Image.Drawing propose deux méthodes pour appliquer le masquage d’image :

  • Masquage manuel – Il utilise un ensemble de ROI comme masque. Les ROI de chaque tranche sont utilisées pour définir le masque. Il nécessite une contribution supplémentaire de l’utilisateur.
  • Masquage automatique - Il ne nécessite pas beaucoup de données d’entrée de la part de l’utilisateur mais peut ne pas être aussi précis.

Voyons maintenant comment appliquer un masquage manuel et automatique sur les images en code C#.

Masquage manuel des images

L’extrait de code suivant montre comment appliquer un masquage manuel sur une image en C#.

string outputFolder = @"Output\";

// Fichier source
string sourceFileName = outputFolder + "couple.png";

// Créer un chemin graphique
GraphicsPath manualMask = new GraphicsPath();

// Ajouter des formes
Figure firstFigure = new Figure();
firstFigure.AddShape(new EllipseShape(new RectangleF(100, 30, 40, 40)));
firstFigure.AddShape(new RectangleShape(new RectangleF(10, 200, 50, 30)));

// Ajouter un chiffre
manualMask.AddFigure(firstFigure);

GraphicsPath subPath = new GraphicsPath();
Figure secondFigure = new Figure();
secondFigure.AddShape(
    new PolygonShape(
     new PointF[]
     {
        new PointF(310, 100), new PointF(350, 200), new PointF(250, 200)

     }, true));

secondFigure.AddShape(new PieShape(new RectangleF(10, 10, 80, 80), 30, 120));
subPath.AddFigure(secondFigure);
manualMask.AddPath(subPath);

// Appliquer un masquage
using (RasterImage image = (RasterImage)Image.Load(sourceFileName))
{
    MaskingOptions maskingOptions = new MaskingOptions()
    {
        Method = SegmentationMethod.Manual,
        Args = new ManualMaskingArgs
        {
            Mask = manualMask
        },
        Decompose = false,
        ExportOptions =
      new PngOptions()
      {
          ColorType = PngColorType.TruecolorWithAlpha,
          Source = new StreamSource(new MemoryStream())
      },
    };
    MaskingResult results = new ImageMasking(image).Decompose(maskingOptions);
    // Sauvegarde du résultat final du masquage.
    using (RasterImage resultImage = (RasterImage)results[1].GetImage())
    {
        resultImage.Save(outputFolder + "manual_masking.png", new PngOptions() { ColorType = PngColorType.TruecolorWithAlpha });
    }
}

Masquage automatique des images

L’extrait de code ci-dessous applique un masquage automatique sur une image à l’aide de l’API de dessin .NET.

string outputFolder = @"Output\";

MaskingResult results;
using (RasterImage image = (RasterImage)Image.Load(outputFolder + "couple.jpg"))
{
    // Pour utiliser Graph Cut avec des traits calculés automatiquement, AutoMaskingGraphCutOptions est utilisé.
    AutoMaskingGraphCutOptions options = new AutoMaskingGraphCutOptions
    {
        // Indique qu'un nouveau calcul des traits par défaut doit être effectué lors de la décomposition de l'image.
        CalculateDefaultStrokes = true,
        
        // Définition du rayon d'adoucissement post-traitement en fonction de la taille de l'image.
        FeatheringRadius = (Math.Max(image.Width, image.Height) / 500) + 1,
        Method = SegmentationMethod.GraphCut,
        Decompose = false,
        ExportOptions =
            new PngOptions()
            {
                ColorType = PngColorType.TruecolorWithAlpha,
                Source = new FileCreateSource(outputFolder + "auto_masking.png")
            },
        BackgroundReplacementColor = Color.Transparent
    };

    results = new ImageMasking(image).Decompose(options);

    using (RasterImage resultImage = (RasterImage)results[1].GetImage())
    {
        resultImage.Save(outputFolder + "auto_masking_2.png", new PngOptions() { ColorType = PngColorType.TruecolorWithAlpha });
    }
}

Appliquer des filtres aux images

L’application de filtres aux images sert à diverses fins et les gens les utilisent pour diverses raisons, à la fois pratiques et artistiques. Les utilisations les plus courantes des filtres d’image incluent la correction des couleurs, l’amélioration de la qualité de l’image, l’application d’effets spéciaux, la réduction du bruit, etc. Aspose.Imaging.Drawing prend en charge plusieurs types de filtres que vous pouvez appliquer aux images, tels que la médiane, le mouvement, le gauss, etc.

Pour une démonstration, jetez un œil au code suivant qui applique le filtre médian à une image à l’aide d’Aspose.Imaging.Drawing.

string templatesFolder = @"Templates\";
string outputFolder = @"Output\";

// Charger l'image bruitée 
using (Image image = Image.Load(templatesFolder + "template.gif"))
{
    // Caster l'image dans RasterImage
    RasterImage rasterImage = image as RasterImage;
    if (rasterImage == null)
    {
        return;
    }

    // Créez une instance de la classe MedianFilterOptions et définissez la taille, appliquez le filtre MedianFilterOptions à l'objet RasterImage et enregistrez l'image résultante.
    MedianFilterOptions options = new MedianFilterOptions(4);
    rasterImage.Filter(image.Bounds, options);

    // Enregistrer l'image
    image.Save(outputFolder + "median_filter.gif");
}

Recadrer, faire pivoter et redimensionner les images

Le recadrage, la rotation et le redimensionnement des images sont considérés comme des fonctionnalités essentielles des applications d’édition d’images. Ce sont les opérations de traitement d’image les plus courantes utilisées pour manipuler des images numériques. Voyons comment recadrer, faire pivoter et redimensionner des images à l’aide de l’API Aspose.Imaging.Drawing.

Recadrer une image

Pour recadrer une image, vous devez fournir les valeurs de décalage pour les quatre côtés de l’image. Sur la base de ces valeurs, les limites de l’image sont décalées vers le centre de l’image. L’extrait de code C# suivant recadre une image en fonction des valeurs de décalage fournies.

string templatesFolder = @"Templates\";
string outputFolder = @"Output\";

// Charger une image existante dans une instance de la classe RasterImage
using (RasterImage rasterImage = (RasterImage)Image.Load(templatesFolder + "template.jpg"))
{
    // Avant le recadrage, l'image doit être mise en cache pour de meilleures performances
    if (!rasterImage.IsCached)
    {
        rasterImage.CacheData();
    }

    // Définir les valeurs de décalage pour les quatre côtés
    int leftShift = 10;
    int rightShift = 10;
    int topShift = 10;
    int bottomShift = 10;

    // En fonction des valeurs de décalage, appliquez le recadrage sur l'image. La méthode de recadrage déplacera les limites de l'image vers le centre de l'image et enregistrera les résultats sur le disque.
    rasterImage.Crop(leftShift, rightShift, topShift, bottomShift);

    // Enregistrer l'image recadrée
    rasterImage.Save(outputFolder + "cropped_image.jpg");
}

Faire pivoter une image

Pour faire pivoter une image, Aspose.Imaging.Drawing fournit la méthode RotateFlip, qui non seulement fait pivoter une image mais la retourne également (si nécessaire). Vous pouvez choisir l’option de rotation et de retournement souhaitée dans l’énumération RotateFlipType. L’extrait de code suivant montre comment faire pivoter une image sans la retourner en C#.

string templatesFolder = @"Templates\";
string outputFolder = @"Output\";

// Chargement et rotation de l'image
using (var image = Image.Load(templatesFolder + "template.jpg"))
{
    // Faire pivoter l'image
    image.RotateFlip(RotateFlipType.Rotate270FlipNone);

    // Enregistrer l'image
    image.Save(outputFolder + "rotated_image.jpg");
}

Redimensionner une image

Redimensionner une image à l’aide d’Aspose.Imaging.Drawing est aussi simple qu’un gâteau. Appelez simplement la méthode Resize et transmettez les nouvelles valeurs de hauteur et de largeur. L’extrait de code suivant montre comment redimensionner une image en C#.

string templatesFolder = @"Templates\";
string outputFolder = @"Output\";

using (Image image = Image.Load(templatesFolder + "template.jpg"))
{
    // Redimensionner l'image
    image.Resize(300, 300);

    // Enregistrer l'image
    image.Save(outputFolder + "resized_image.jpg");
}

Convertir des images vers d’autres formats

Pour convertir une image à l’aide de l’API Aspose.Imaging.Drawing, il vous suffit de charger l’image et de l’enregistrer dans le format de sortie souhaité. L’extrait de code suivant convertit une image JPG aux formats WebP, PSD, PDF et TIFF.

string templatesFolder = @"Templates\";
string outputFolder = @"Output\";

using (var img = Aspose.Imaging.Image.Load(templatesFolder + "template.jpg"))
{
    // Enregistrer dans différents formats d'image
    img.Save(outputFolder + "output.webp", new Aspose.Imaging.ImageOptions.WebPOptions());
    img.Save(outputFolder + "output.psd ", new Aspose.Imaging.ImageOptions.PsdOptions());
    img.Save(outputFolder + "output.tiff", new Aspose.Imaging.ImageOptions.TiffOptions(TiffExpectedFormat.Default));

    // Enregistrer au format PDF
    PdfOptions exportOptions = new PdfOptions();
    exportOptions.PdfDocumentInfo = new Aspose.Imaging.FileFormats.Pdf.PdfDocumentInfo();
    img.Save(outputFolder + "output.pdf", exportOptions);
}

Obtenez une licence API gratuite

Si vous souhaitez évaluer l’API Aspose.Imaging.Drawing, vous pouvez obtenir une licence temporaire gratuite qui vous permet d’utiliser l’API à sa pleine capacité sans aucune limitation.

Conclusion

Dans le domaine des graphiques et du traitement d’images, l’API Aspose.Imaging.Drawing s’impose comme un outil polyvalent et puissant pour les développeurs C# .NET. Que vous cherchiez à améliorer des éléments visuels, à corriger les distorsions d’images ou à convertir des images entre formats, cette API fournit un ensemble complet de fonctionnalités. Avec Aspose.Imaging.Drawing, la manipulation d’images est à portée de main, vous permettant de créer par programme des graphiques convaincants et visuellement époustouflants.

Faites-nous part de vos commentaires ou de vos questions sur notre forum.