Zeichnen Sie Raster und Vektorbilder

Unabhängig davon, ob Sie eine Website, eine Desktop-Anwendung oder eine mobile App erstellen, ist die Fähigkeit, Bilder zu manipulieren und darauf zu zeichnen, ein entscheidender Aspekt bei der Verarbeitung und Bearbeitung von Bildern. Um Entwicklern erweiterte und dennoch einfach zu implementierende Zeichenfunktionen zur Verfügung zu stellen, stellen wir Aspose.Imaging.Drawing vor, eine leistungsstarke API, die für C# .NET-Anwendungen entwickelt wurde und eine Reihe von Funktionen zum Zeichnen von Bildern bietet.

C# .NET-Zeichnungsbibliothek

Aspose.Imaging.Drawing ist eine robuste API, die es Ihnen ermöglicht, Raster und Vektorbilder mit fortschrittlichen Bildverarbeitungstechniken zu verarbeiten. Mit nativem Byte-Zugriff sorgt die API für eine hohe Verarbeitungsgeschwindigkeit beim Erstellen oder Bearbeiten von Bildern. Mithilfe der API können Sie Objekte mit Pixelmanipulation und Grafikpfad zeichnen und Bilder von einem Format in ein anderes konvertieren. Aspose.Imaging.Drawing verwendet Aspose.Drawing als Standard-Grafik-Engine, eine plattformübergreifende 2D-Grafikbibliothek, die einen vollständigen Satz an Funktionen zum Zeichnen von Text, Geometrien und Bildern ohne externe Abhängigkeiten bietet.

Sie können Aspose.Imaging.Drawing von NuGet herunterladen und installieren.

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

Werfen wir nun einen Blick auf einige herausragende Funktionen dieser .NET-Zeichnungs-API und deren Verwendung mithilfe des Quellcodes.

Erstellen von Grafiken mit der .NET-Zeichnungsbibliothek

Mit Aspose.Imaging.Drawing können Sie Bilder erstellen, indem Sie verschiedene Objekte wie Kreise, Linien, Dreiecke, Quadrate und Ellipsen zeichnen. Mit der API können Sie nicht nur Rasterbilder, sondern auch Vektorbilder generieren. Sehen wir uns an, wie man mit dieser .NET-Zeichen-API Raster und Vektorbilder in C# zeichnet.

Rasterbild zeichnen

Nachfolgend finden Sie die Schritte zum Zeichnen eines Rasterbilds mithilfe der Aspose.Imaging.Drawing-API.

  • Erstellen Sie zunächst ein Bild im gewünschten Format mit der Methode Image.Create().
  • Erstellen Sie dann ein Objekt der Graphics Klasse und initialisieren Sie es mit dem oben erstellten Image.
  • Löschen Sie die Oberfläche des Bildes mit der Graphics.Clear-Methode.
  • Erstellen Sie einen neuen Stift und initialisieren Sie ihn mit der gewünschten Farbe.
  • Zeichnen Sie eine Ellipse (oder ein anderes grafisches Objekt) mit der Methode Graphics.DrawEllipse().
  • Zeichnen Sie ein Polygon mit der Graphics.FillPolygon()-Methode.
  • Speichern Sie abschließend das Bild mit der Methode Image.Save().

Der folgende Codeausschnitt zeigt, wie man ein Bild in C# zeichnet.

string outputFolder = @"Output\";

// Erstellen Sie eine Instanz von BmpOptions und legen Sie deren verschiedene Eigenschaften fest
BmpOptions imageOptions = new BmpOptions();
imageOptions.BitsPerPixel = 24;

// Erstellen Sie eine Instanz von FileCreateSource und weisen Sie sie der Source-Eigenschaft zu 
imageOptions.Source = new FileCreateSource(outputFolder + "result.bmp", false);

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

    // Löschen Sie die Bildoberfläche mit weißer Farbe und erstellen und initialisieren Sie ein Stiftobjekt mit blauer Farbe
    graphics.Clear(Color.White);
    var pen = new Pen(Color.Blue);

    // Zeichnen Sie eine Ellipse, indem Sie das umgebende Rechteck mit einer Breite von 150 und einer Höhe von 100 definieren. Zeichnen Sie außerdem ein Polygon mit dem 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) });
    }

    // Bild speichern
    image.Save();
}

Vektorbild zeichnen

Ähnlich wie bei Rasterbildern können Sie in wenigen einfachen Schritten Vektorgrafiken wie SVG zeichnen. Lassen Sie uns mithilfe unserer C#-Zeichnungsbibliothek ein Vektorbild erstellen.

  • Erstellen Sie zunächst ein MemoryStream Objekt.
  • Laden Sie dann ein SVG bild.
  • Rasterisieren Sie SVG in PNG und schreiben Sie das Ergebnis in einen Stream.
  • Laden Sie ein PNG bild aus dem Stream zum weiteren Zeichnen.
  • Zeichnen Sie ein PNG bild auf ein vorhandenes SVG bild.
  • Speichern Sie abschließend die Ergebnisse.

Der folgende Codeausschnitt zeigt, wie man ein Vektorbild in C# zeichnet.

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

using (MemoryStream drawnImageStream = new MemoryStream())
{
    // Rastern Sie zunächst SVG in PNG und schreiben Sie das Ergebnis in einen Stream.
    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);

        // Laden Sie nun ein PNG bild aus dem Stream zum weiteren Zeichnen.
        drawnImageStream.Seek(0, System.IO.SeekOrigin.Begin);
        using (RasterImage imageToDraw = (RasterImage)Image.Load(drawnImageStream))
        {
            // Basierend auf dem vorhandenen SVG bild.
            Aspose.Imaging.FileFormats.Svg.Graphics.SvgGraphics2D graphics = new Aspose.Imaging.FileFormats.Svg.Graphics.SvgGraphics2D(svgImage);

            // Verkleinern Sie das gesamte gezeichnete Bild um das Zweifache und zeichnen Sie es in die Mitte der Zeichenfläche.
            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);

            // Speichern Sie das Ergebnisbild
            using (SvgImage resultImage = graphics.EndRecording())
            {
                resultImage.Save(outputFolder + "vector_image.svg");
            }
        }
    }
}

Maskierung auf Bilder anwenden

Als Maskierung bezeichnet man in der Bildbearbeitung die Technik, bestimmte Teile eines Bildes gezielt auszublenden oder sichtbar zu machen. Dabei wird eine Maske erstellt, bei der es sich im Wesentlichen um ein Graustufenbild handelt, das die Transparenz oder Opazität jedes Pixels im Originalbild definiert. Bildmaskierung wird häufig zur Erkennung und Diagnose eingesetzt.

Aspose.Image.Drawing bietet zwei Methoden zum Anwenden der Bildmaskierung:

  • Manuelle Maskierung – Es wird eine Reihe von ROIs als Maske verwendet. Die ROIs für jedes Segment werden zur Definition der Maske verwendet. Es sind zusätzliche Benutzereingaben erforderlich.
  • Automatische Maskierung – Es erfordert nicht viele Eingabedaten vom Benutzer, ist aber möglicherweise nicht so genau.

Sehen wir uns nun an, wie man in C#-Code manuelle und automatische Maskierung auf Bilder anwendet.

Manuelle Bildmaskierung

Der folgende Codeausschnitt zeigt, wie man in C# eine manuelle Maskierung auf ein Bild anwendet.

string outputFolder = @"Output\";

// Quelldatei
string sourceFileName = outputFolder + "couple.png";

// Grafikpfad erstellen
GraphicsPath manualMask = new GraphicsPath();

// Formen hinzufügen
Figure firstFigure = new Figure();
firstFigure.AddShape(new EllipseShape(new RectangleF(100, 30, 40, 40)));
firstFigure.AddShape(new RectangleShape(new RectangleF(10, 200, 50, 30)));

// Figur hinzufügen
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);

// Maskierung anwenden
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);
    // Speichern des endgültigen Maskierungsergebnisses.
    using (RasterImage resultImage = (RasterImage)results[1].GetImage())
    {
        resultImage.Save(outputFolder + "manual_masking.png", new PngOptions() { ColorType = PngColorType.TruecolorWithAlpha });
    }
}

Automatische Bildmaskierung

Der folgende Codeausschnitt wendet mithilfe der .NET-Zeichen-API die automatische Maskierung auf ein Bild an.

string outputFolder = @"Output\";

MaskingResult results;
using (RasterImage image = (RasterImage)Image.Load(outputFolder + "couple.jpg"))
{
    // Um Graph Cut mit automatisch berechneten Strichen zu verwenden, wird AutoMaskingGraphCutOptions verwendet.
    AutoMaskingGraphCutOptions options = new AutoMaskingGraphCutOptions
    {
        // Gibt an, dass während der Bildzerlegung eine neue Berechnung der Standardstriche durchgeführt werden soll.
        CalculateDefaultStrokes = true,
        
        // Festlegen des Nachbearbeitungsradius für die Ausfransung basierend auf der Bildgröße.
        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 });
    }
}

Wenden Sie Filter auf Bilder an

Das Anwenden von Filtern auf Bilder dient verschiedenen Zwecken und Menschen nutzen sie aus unterschiedlichen praktischen und künstlerischen Gründen. Zu den häufigsten Anwendungen von Bildfiltern gehören Farbkorrektur, Verbesserung der Bildqualität, Anwendung von Spezialeffekten, Rauschunterdrückung usw. Aspose.Imaging.Drawing unterstützt verschiedene Arten von Filtern, die Sie auf die Bilder anwenden können, z. B. Median, Bewegungs-Weiner, Gauß-Weiner usw.

Schauen Sie sich zur Demonstration den folgenden Code an, der den Medianfilter mithilfe von Aspose.Imaging.Drawing auf ein Bild anwendet.

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

// Laden Sie das verrauschte Bild 
using (Image image = Image.Load(templatesFolder + "template.gif"))
{
    // Wandeln Sie das Bild in RasterImage um
    RasterImage rasterImage = image as RasterImage;
    if (rasterImage == null)
    {
        return;
    }

    // Erstellen Sie eine Instanz der MedianFilterOptions Klasse und legen Sie die Größe fest, wenden Sie den MedianFilterOptions-Filter auf das RasterImage Objekt an und speichern Sie das resultierende Bild
    MedianFilterOptions options = new MedianFilterOptions(4);
    rasterImage.Filter(image.Bounds, options);

    // Bild speichern
    image.Save(outputFolder + "median_filter.gif");
}

Bilder zuschneiden, drehen und in der Größe ändern

Zuschneiden, Drehen und Ändern der Bildgröße gelten als wesentliche Funktionen von Bildbearbeitungsanwendungen. Dabei handelt es sich um die gebräuchlichsten Bildverarbeitungsvorgänge, mit denen digitale Bilder manipuliert werden. Sehen wir uns an, wie Sie Bilder mithilfe der Aspose.Imaging.Drawing-API zuschneiden, drehen und in der Größe ändern.

Beschneiden Sie ein Bild

Um ein Bild zuzuschneiden, müssen Sie die Verschiebungswerte für alle vier Seiten des Bildes angeben. Basierend auf diesen Werten werden die Bildgrenzen zur Bildmitte hin verschoben. Der folgende C#-Codeausschnitt schneidet ein Bild basierend auf den bereitgestellten Verschiebungswerten zu.

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

// Laden Sie ein vorhandenes Bild in eine Instanz der RasterImage Klasse
using (RasterImage rasterImage = (RasterImage)Image.Load(templatesFolder + "template.jpg"))
{
    // Vor dem Zuschneiden sollte das Bild für eine bessere Leistung zwischengespeichert werden
    if (!rasterImage.IsCached)
    {
        rasterImage.CacheData();
    }

    // Definieren Sie Verschiebungswerte für alle vier Seiten
    int leftShift = 10;
    int rightShift = 10;
    int topShift = 10;
    int bottomShift = 10;

    // Wenden Sie basierend auf den Verschiebungswerten den Zuschnitt auf das Bild an. Die Zuschneidemethode verschiebt die Bildgrenzen in Richtung der Bildmitte und speichert die Ergebnisse auf der Festplatte
    rasterImage.Crop(leftShift, rightShift, topShift, bottomShift);

    // Zugeschnittenes Bild speichern
    rasterImage.Save(outputFolder + "cropped_image.jpg");
}

Drehen Sie ein Bild

Um ein Bild zu drehen, bietet Aspose.Imaging.Drawing die RotateFlip-Methode, die ein Bild nicht nur dreht, sondern bei Bedarf auch umdreht. Sie können die gewünschte Rotations und Spiegelungsoption aus der RotateFlipType-Enumeration auswählen. Der folgende Codeausschnitt zeigt, wie man ein Bild in C# dreht, aber nicht umdreht.

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

// Bild laden und drehen
using (var image = Image.Load(templatesFolder + "template.jpg"))
{
    // Bild drehen
    image.RotateFlip(RotateFlipType.Rotate270FlipNone);

    // Bild speichern
    image.Save(outputFolder + "rotated_image.jpg");
}

Ändern Sie die Größe eines Bildes

Die Größenänderung eines Bildes mit Aspose.Imaging.Drawing ist kinderleicht. Rufen Sie einfach die Resize-Methode auf und übergeben Sie die neuen Höhen und Breitenwerte. Der folgende Codeausschnitt zeigt, wie man die Größe eines Bildes in C# ändert.

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

using (Image image = Image.Load(templatesFolder + "template.jpg"))
{
    // Bildgröße anpassen
    image.Resize(300, 300);

    // Bild speichern
    image.Save(outputFolder + "resized_image.jpg");
}

Konvertieren Sie Bilder in andere Formate

Um ein Bild mithilfe der Aspose.Imaging.Drawing-API zu konvertieren, müssen Sie nur das Bild laden und im gewünschten Ausgabeformat speichern. Der folgende Codeausschnitt konvertiert ein JPG bild in die Formate WebP, PSD, PDF und TIFF.

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

using (var img = Aspose.Imaging.Image.Load(templatesFolder + "template.jpg"))
{
    // Speichern Sie in verschiedenen Bildformaten
    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));

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

Holen Sie sich eine kostenlose API Lizenz

Wenn Sie die Aspose.Imaging.Drawing API evaluieren möchten, können Sie eine kostenlose temporäre Lizenz erhalten, mit der Sie die API ohne Einschränkungen in vollem Umfang nutzen können.

Abschluss

Im Bereich der Grafik und Bildverarbeitung zeichnet sich die Aspose.Imaging.Drawing API als vielseitiges und leistungsstarkes Tool für C# .NET-Entwickler aus. Unabhängig davon, ob Sie visuelle Elemente verbessern, Bildverzerrungen korrigieren oder Bilder zwischen Formaten konvertieren möchten, bietet diese API umfassende Funktionen. Mit Aspose.Imaging.Drawing steht Ihnen die Bildbearbeitung zur Verfügung und Sie können programmgesteuert überzeugende und visuell beeindruckende Grafiken erstellen.

Teilen Sie uns Ihr Feedback oder Ihre Fragen in unserem Forum mit.