Rita raster och vektorbilder

Oavsett om du bygger en webbplats, en stationär applikation eller en mobilapp, är förmågan att manipulera och rita på bilder en avgörande aspekt när du bearbetar och redigerar bilder. För att ge utvecklare avancerade men ändå lätta att implementera ritfunktioner introducerar vi Aspose.Imaging.Drawing, ett kraftfullt API designat för C# .NET-applikationer, som erbjuder en rad bildritningsfunktioner.

C# .NET Ritningsbibliotek

Aspose.Imaging.Drawing är ett robust API som låter dig bearbeta raster- och vektorbilder med avancerad bildbehandlingsteknik. Med inbyggd byte-åtkomst säkerställer API:et hög bearbetningshastighet medan du skapar eller manipulerar bilder. Med hjälp av API:t kan du rita objekt med pixelmanipulation och grafisk väg och konvertera bilder från ett format till ett annat. Aspose.Imaging.Drawing använder Aspose.Drawing som standardgrafikmotor, vilket är ett plattformsoberoende 2D-grafikbibliotek som erbjuder en komplett uppsättning funktioner för att rita text, geometrier och bilder utan några externa beroenden.

Du kan ladda ner och installera Aspose.Imaging.Drawing från NuGet.

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

Låt oss nu ta en titt på några framträdande egenskaper hos detta .NET Drawing API och deras användning med hjälp av källkod.

Skapa grafik med .NET Drawing Library

Aspose.Imaging.Drawing låter dig skapa bilder genom att rita olika objekt som cirklar, linjer, trianglar, fyrkanter och ellipser. Inte bara rasterbilderna utan du kan generera vektorbilder med hjälp av API:et. Låt oss ta en titt på hur man ritar raster- och vektorbilder i C# med detta .NET-ritnings-API.

Rita rasterbild

Nedan följer stegen för att rita en rasterbild med Aspose.Imaging.Drawing API.

  • Skapa först en bild av önskat format med metoden Image.Create().
  • Skapa sedan ett objekt av klassen Graphics och initiera det med Image som vi har skapat ovan.
  • Rensa bildens yta med Graphics.Clear-metoden.
  • Skapa en ny penna och initiera den med önskad färg.
  • Rita en ellips (eller något annat grafiskt objekt) med metoden Graphics.DrawEllipse().
  • Rita en polygon med metoden Graphics.FillPolygon().
  • Slutligen sparar du bilden med metoden Image.Save().

Följande kodsnutt visar hur man ritar en bild i C#.

string outputFolder = @"Output\";

// Skapa en instans av BmpOptions och ställ in dess olika egenskaper
BmpOptions imageOptions = new BmpOptions();
imageOptions.BitsPerPixel = 24;

// Skapa en instans av FileCreateSource och tilldela den till Source-egenskapen 
imageOptions.Source = new FileCreateSource(outputFolder + "result.bmp", false);

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

    // Rensa bildytan med vit färg och Skapa och initiera ett Pen-objekt med blå färg
    graphics.Clear(Color.White);
    var pen = new Pen(Color.Blue);

    // Rita Ellips genom att definiera avgränsningsrektangeln med bredd 150 och höjd 100 Rita också en polygon med 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) });
    }

    // Spara bild
    image.Save();
}

Rita vektorbild

I likhet med rasterbilder kan du rita vektorgrafik, som SVG, i några enkla steg. Låt oss skapa en vektorbild med vårt ritbibliotek i C#.

  • Skapa först ett MemoryStream-objekt.
  • Ladda sedan en SVG-bild.
  • Rasterisera SVG till PNG och skriv resultatet till en stream.
  • Ladda en PNG-bild från strömmen för vidare ritning.
  • Rita PNG-bild på befintlig SVG-bild.
  • Spara slutligen resultaten.

Följande kodsnutt visar hur man ritar en vektorbild i C#.

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

using (MemoryStream drawnImageStream = new MemoryStream())
{
    // Rasterisera först Svg till Png och skriv resultatet till en 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);

        // Ladda nu en Png-bild från stream för vidare ritning.
        drawnImageStream.Seek(0, System.IO.SeekOrigin.Begin);
        using (RasterImage imageToDraw = (RasterImage)Image.Load(drawnImageStream))
        {
            // Ritar på den befintliga Svg-bilden.
            Aspose.Imaging.FileFormats.Svg.Graphics.SvgGraphics2D graphics = new Aspose.Imaging.FileFormats.Svg.Graphics.SvgGraphics2D(svgImage);

            // Skala ner hela den ritade bilden med 2 gånger och rita den till mitten av ritytan.
            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);

            // Spara resultatbilden
            using (SvgImage resultImage = graphics.EndRecording())
            {
                resultImage.Save(outputFolder + "vector_image.svg");
            }
        }
    }
}

Tillämpa maskering på bilder

Maskering i bildredigering hänvisar till tekniken att selektivt dölja eller avslöja vissa delar av en bild. Det innebär att skapa en mask, som i huvudsak är en gråskalebild som definierar transparensen eller opaciteten för varje pixel i originalbilden. Bildmaskering används i stor utsträckning för igenkänning och diagnostik.

Aspose.Image.Drawing tillhandahåller två metoder för att applicera bildmaskering:

  • Manuell maskering - Den använder en uppsättning ROIs som mask. ROI för varje segment används för att definiera masken. Det kräver ytterligare användarinput.
  • Automatisk maskering - Det kräver inte mycket indata från användaren men kanske inte är så exakt.

Låt oss nu se hur man tillämpar manuell och automatisk maskering på bilder i C#-kod.

Manuell bildmaskering

Följande kodsnutt visar hur man applicerar manuell maskering på en bild i C#.

string outputFolder = @"Output\";

// Källfilen
string sourceFileName = outputFolder + "couple.png";

// Skapa grafisk väg
GraphicsPath manualMask = new GraphicsPath();

// Lägg till former
Figure firstFigure = new Figure();
firstFigure.AddShape(new EllipseShape(new RectangleF(100, 30, 40, 40)));
firstFigure.AddShape(new RectangleShape(new RectangleF(10, 200, 50, 30)));

// Lägg till figur
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);

// Applicera maskering
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);
    // Sparar slutligt maskeringsresultat.
    using (RasterImage resultImage = (RasterImage)results[1].GetImage())
    {
        resultImage.Save(outputFolder + "manual_masking.png", new PngOptions() { ColorType = PngColorType.TruecolorWithAlpha });
    }
}

Automatisk bildmaskering

Kodavsnittet nedan tillämpar automatisk maskering på en bild med .NET drawing API.

string outputFolder = @"Output\";

MaskingResult results;
using (RasterImage image = (RasterImage)Image.Load(outputFolder + "couple.jpg"))
{
    // För att använda Graph Cut med automatiskt beräknade slag, används AutoMaskingGraphCutOptions.
    AutoMaskingGraphCutOptions options = new AutoMaskingGraphCutOptions
    {
        // Indikerar att en ny beräkning av standardlinjerna ska utföras under bildnedbrytningen.
        CalculateDefaultStrokes = true,
        
        // Ställa in efterbearbetningsradie baserat på bildstorleken.
        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 });
    }
}

Använd filter på bilder

Att använda filter på bilder tjänar olika syften, och människor använder dem av en mängd olika skäl, både praktiska och konstnärliga. De vanligaste användningsområdena för bildfilter inkluderar färgkorrigering, förbättring av bildkvalitet, tillämpning av specialeffekter, brusreducering och så vidare. Aspose.Imaging.Drawing stöder flera typer av filter som du kan applicera på bilderna, som median, motion weiner, gauss weiner, etc.

För demonstration, ta en titt på följande kod som tillämpar medianfiltret på en bild med Aspose.Imaging.Drawing.

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

// Ladda den brusiga bilden 
using (Image image = Image.Load(templatesFolder + "template.gif"))
{
    // Casta bilden till RasterImage
    RasterImage rasterImage = image as RasterImage;
    if (rasterImage == null)
    {
        return;
    }

    // Skapa en instans av MedianFilterOptions-klassen och ställ in storleken, använd MedianFilterOptions-filtret på RasterImage-objektet och spara den resulterande bilden
    MedianFilterOptions options = new MedianFilterOptions(4);
    rasterImage.Filter(image.Bounds, options);

    // Spara bild
    image.Save(outputFolder + "median_filter.gif");
}

Beskär, rotera och ändra storlek på bilder

Att beskära, rotera och ändra storlek på bilder anses vara de viktigaste funktionerna i bildredigeringsapplikationer. De är de vanligaste bildbehandlingsoperationerna som används för att manipulera digitala bilder. Låt oss ta en titt på hur man beskär, roterar och ändrar storlek på bilder med Aspose.Imaging.Drawing API.

Beskär en bild

För att beskära en bild måste du ange skiftvärdena för alla fyra sidorna av bilden. Baserat på dessa värden förskjuts bildgränserna mot mitten av bilden. Följande C#-kodavsnitt beskär en bild baserat på de angivna skiftvärdena.

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

// Ladda en befintlig bild i en instans av RasterImage-klassen
using (RasterImage rasterImage = (RasterImage)Image.Load(templatesFolder + "template.jpg"))
{
    // Innan beskärning bör bilden cachelagras för bättre prestanda
    if (!rasterImage.IsCached)
    {
        rasterImage.CacheData();
    }

    // Definiera skiftvärden för alla fyra sidorna
    int leftShift = 10;
    int rightShift = 10;
    int topShift = 10;
    int bottomShift = 10;

    // Baserat på skiftvärdena, använd beskärning på bild Beskärningsmetoden kommer att flytta bildgränserna mot mitten av bilden och spara resultaten på disk
    rasterImage.Crop(leftShift, rightShift, topShift, bottomShift);

    // Spara beskuren bild
    rasterImage.Save(outputFolder + "cropped_image.jpg");
}

Rotera en bild

För att rotera en bild tillhandahåller Aspose.Imaging.Drawing RotateFlip-metoden, som inte bara roterar en bild utan också vänder den (om det behövs). Du kan välja önskat rotations- och vändningsalternativ från RotateFlipType enum. Följande kodavsnitt visar hur man roterar en bild men inte vänder den i C#.

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

// Laddar och roterar bild
using (var image = Image.Load(templatesFolder + "template.jpg"))
{
    // Rotera bilden
    image.RotateFlip(RotateFlipType.Rotate270FlipNone);

    // Spara bild
    image.Save(outputFolder + "rotated_image.jpg");
}

Ändra storlek på en bild

Ändra storlek på en bild med Aspose.Imaging.Drawing är enkelt som en plätt. Anropa bara Resize-metoden och skicka de nya höjd- och breddvärdena. Följande kodsnutt visar hur man ändrar storlek på en bild i C#.

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

using (Image image = Image.Load(templatesFolder + "template.jpg"))
{
    // Ändra storlek på bild
    image.Resize(300, 300);

    // Spara bild
    image.Save(outputFolder + "resized_image.jpg");
}

Konvertera bilder till andra format

För att konvertera en bild med Aspose.Imaging.Drawing API behöver du bara ladda bilden och spara den i önskat utdataformat. Följande kodsnutt konverterar en JPG-bild till WebP-, PSD-, PDF- och TIFF-format.

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

using (var img = Aspose.Imaging.Image.Load(templatesFolder + "template.jpg"))
{
    // Spara i olika bildformat
    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));

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

Skaffa en gratis API-licens

Om du vill utvärdera Aspose.Imaging.Drawing API kan du få en gratis temporär licens som låter dig använda API till sin fulla kapacitet utan några begränsningar.

Slutsats

När det gäller grafik och bildbehandling framstår Aspose.Imaging.Drawing API som ett mångsidigt och kraftfullt verktyg för C# .NET-utvecklare. Oavsett om du vill förbättra visuella element, korrigera bildförvrängningar eller konvertera bilder mellan format, erbjuder detta API en omfattande uppsättning funktioner. Med Aspose.Imaging.Drawing kommer bildmanipulation till hands, vilket ger dig möjlighet att skapa övertygande och visuellt imponerande grafik programmässigt.

Låt oss veta om din feedback eller frågor på vårt forum.