Ta bort bakgrund från bilder i C#

Vid skapande och manipulering av digitalt innehåll är det en vanlig och viktig uppgift att ta bort bakgrunden från bilder. Oavsett om du arbetar med grafisk design, e-handel eller vilket annat visuellt projekt som helst, ökar din kreativitet att ha möjligheten att isolera objekt från deras bakgrunder. I det här blogginlägget kommer vi att utforska hur man tar bort bakgrund från bilder programmatiskt i C#.

• C#-bibliotek för att ta bort bakgrund från bilder
• Ta bort bildbakgrund med automatisk maskering
  • Graph Cut Auto Masking med Feathering
  • Återanvändning av standardslag i upprepad automatisk maskering
  • Grafklipp automatisk maskering med antagna objektdata
• Bakgrundsborttagning med manuell maskering

C#-bibliotek för att ta bort bakgrund från bilder

För att ta bort bakgrund från bilder kommer vi att använda Aspose.Imaging for .NET – ett kraftfullt bibliotek som tillhandahåller ett brett utbud av bildbehandlingsfunktioner för .NET-applikationer. Det stöder olika bildformat och låter utvecklare utföra operationer som att ändra storlek, beskära, rotera och, naturligtvis, ta bort bakgrunder med lätthet.

Du kan antingen ladda ner API:t eller installera det från NuGet.

PM> Install-Package Aspose.Imaging

Ta bort bildbakgrund med automatisk maskering i C#

För att få bättre resultat för borttagning av bakgrund, är automatisk maskeringsmetod att föredra. Målet är att skapa en mask som exakt identifierar pixlarna som hör till förgrunden och de som hör till bakgrunden. Aspose.Imaging tillhandahåller tre automatiska maskeringstekniker för att ta bort bakgrund från bilden, enligt beskrivningen i följande avsnitt.

Graph Cut Auto Masking med Feathering

I den här tekniken utför API:et bildmaskering med fjädring baserat på bildstorlek och använder automatiskt beräknade standardslag. Följande kodavsnitt visar hur man använder grafklippt automatisk maskering med utjämning. Args-egenskapen för AutoMaskingGraphCutOptions kan utelämnas eftersom standardlinjer placeras där i slutet.

using Aspose.Imaging;
using Aspose.Imaging.FileFormats.Png;
using Aspose.Imaging.ImageOptions;
using Aspose.Imaging.Masking;
using Aspose.Imaging.Masking.Options;
using Aspose.Imaging.Masking.Result;
using Aspose.Imaging.Sources;
using System;
using System.IO;

string templatesFolder = @"c:\Users\USER\Downloads\templates\";
string dataDir = templatesFolder;

MaskingResult results;
using (RasterImage image = (RasterImage)Image.Load(dataDir + "couple.jpg"))
{
    // För att använda Graph Cut med automatiskt beräknade linjer, 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(dataDir + "result.png")
                                                        },
        BackgroundReplacementColor = Color.Transparent
    };

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

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



File.Delete(dataDir + "result.png");
File.Delete(dataDir + "result2.png");

Följande skärmdump visar ingångs- och utmatningsbilderna.

Återanvändning av standardslag i upprepad automatisk maskering

I den här tekniken görs bildmaskeringen med automatiskt beräknade standardlinjer, men API:et återanvänder maskeringsalternativen för den nya maskeringsiterationen. I följande kodavsnitt kan du lägga märke till att data för de två antagna objekten också anges i egenskapen AssumedObjects i AutoMaskingGraphCutOptions. Efter de initiala maskeringsresultaten görs justeringar av de applicerade bakgrunds-/förgrundsslagen, och en efterföljande iteration av maskeringen utförs.

using Aspose.Imaging;
using Aspose.Imaging.FileFormats.Png;
using Aspose.Imaging.ImageOptions;
using Aspose.Imaging.Masking;
using Aspose.Imaging.Masking.Options;
using Aspose.Imaging.Masking.Result;
using Aspose.Imaging.Sources;
using System;
using System.Collections.Generic;
using System.IO;

string templatesFolder = @"c:\Users\USER\Downloads\templates\";
string dataDir = templatesFolder;

// För att förbättra maskeringsresultaten kan data för de specifika objekt som ska inkluderas i förgrundsmaskeringsresultatet tillhandahållas.
List<AssumedObjectData> assumedObjects = new List<AssumedObjectData>();
// Objekttypen och området som innehåller det objektet ska anges.
assumedObjects.Add(new AssumedObjectData(DetectedObjectType.Human, new Rectangle(0, 0, 300, 300)));

MaskingResult results;
AutoMaskingGraphCutOptions options;
Point[] appliedBackgroundStrokes;
Point[] appliedForegroundStrokes;
Rectangle[] appliedObjectRectangles;

using (RasterImage image = (RasterImage)Image.Load(dataDir + "couple.jpg"))
{
    // För att använda Graph Cut med automatiskt beräknade linjer, används AutoMaskingGraphCutOptions.
    options = new AutoMaskingGraphCutOptions
    {
        AssumedObjects = assumedObjects,
        // 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(dataDir + "result.png")
        },
        BackgroundReplacementColor = Color.Transparent
    };

    using (IMaskingSession maskingSession = new ImageMasking(image).CreateSession(options))
    {
        results = maskingSession.Decompose();

        // Sparar mellanliggande maskeringsresultat.
        using (RasterImage resultImage = results[1].GetImage())
        {
            resultImage.Save(dataDir + "result2.png",
                new PngOptions() { ColorType = PngColorType.TruecolorWithAlpha });
        }

        // Vid denna punkt kan applicerade förgrunds-/bakgrundslinjer analyseras och baseras på det ytterligare 
        // förgrunds-/bakgrundsdrag kan tillhandahållas manuellt.
        appliedBackgroundStrokes = options.DefaultBackgroundStrokes;
        appliedForegroundStrokes = options.DefaultForegroundStrokes;
        appliedObjectRectangles = options.DefaultObjectsRectangles;

        // Om du återanvänder AutoMaskingGraphCutOptions behöver du inte utföra standardslagberäkningar en andra gång.
        // När både standardlinjer och ObjectsPoints i Args-egenskapen för AutoMaskingArgs tillhandahålls, kombineras punktmatriser.
        // Den första ObjectsPoints-matrisen anses vara en bakgrundspoängmatris och 
        // den andra ObjectsPoints-matrisen anses vara en förgrundspunktsmatris.
        // När både DefaultObjectsRectangles och ObjectsRectangles i egenskapen Args för AutoMaskingArgs tillhandahålls, 
        // endast arrayen från Args används.
        AutoMaskingArgs newAutoMaskingArgs = new AutoMaskingArgs()
        {
            ObjectsPoints = new Point[][]
            {
                // Dessutom specificerar vi områden som vi vill ta bort.
                GetRectanglePoints(
                    new Rectangle(100, 100, 35, 90),
                    new Rectangle(300, 140, 95, 50)
                )
            },
        };

        results = maskingSession.ImproveDecomposition(newAutoMaskingArgs);

        using (RasterImage resultImage = results[1].GetImage())
        {
            resultImage.Save(dataDir +
                "result3.png",
                new PngOptions() { ColorType = PngColorType.TruecolorWithAlpha });
        }
    }
}
//Exempel - graf - klipp - upprepas - maskering - med - nya-punkter.cs
// För att förbättra maskeringsresultaten kan data för de specifika objekt som ska inkluderas i förgrundsmaskeringsresultatet tillhandahållas.
assumedObjects = new List<AssumedObjectData>();
// Objekttypen och området som innehåller det objektet ska anges.
assumedObjects.Add(new AssumedObjectData(DetectedObjectType.Human, new Rectangle(100, 100, 150, 300)));

// Första maskeringsiterationen utförs för att få automatiskt beräknade förgrunds-/bakgrundspenseldrag.
using (RasterImage image = (RasterImage)Image.Load(dataDir + "couple.jpg"))
{
    // För att använda Graph Cut med automatiskt beräknade linjer, används AutoMaskingGraphCutOptions.
    options = new AutoMaskingGraphCutOptions
    {
        AssumedObjects = assumedObjects,
        // Indikerar att en ny beräkning av standardlinjerna ska utföras under bildnedbrytningen.
        CalculateDefaultStrokes = true,
        // Inställning av efterbearbetningsradie.
        FeatheringRadius = 3,
        Method = SegmentationMethod.GraphCut,
        Decompose = false,
        ExportOptions =
                            new PngOptions()
                            {
                                ColorType = PngColorType.TruecolorWithAlpha,
                                Source = new FileCreateSource(dataDir + "result4.png")
                            },
        BackgroundReplacementColor = Color.Transparent
    };

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

    // Vid denna punkt kan applicerade förgrunds-/bakgrundslinjer analyseras och baseras på det ytterligare 
    // förgrunds-/bakgrundsdrag kan tillhandahållas manuellt.
    appliedBackgroundStrokes = options.DefaultBackgroundStrokes;
    appliedForegroundStrokes = options.DefaultForegroundStrokes;
    appliedObjectRectangles = options.DefaultObjectsRectangles;
    using (RasterImage resultImage = (RasterImage)results[1].GetImage())
    {
        resultImage.Save(dataDir + "result5.png", new PngOptions() { ColorType = PngColorType.TruecolorWithAlpha });
    }
}



// Andra maskeringsiterationen utförs för att ytterligare förbättra maskeringskvaliteten genom att lägga till nya manuellt valda förgrunds-/bakgrundspunkter.
using (RasterImage image = (RasterImage)Image.Load(dataDir + "couple.jpg"))
{
    // Om du återanvänder AutoMaskingGraphCutOptions behöver du inte utföra standardslagberäkningar en andra gång.
    options.CalculateDefaultStrokes = false;
    // När både standardlinjer och ObjectsPoints i Args-egenskapen för AutoMaskingArgs tillhandahålls, kombineras punktmatriser.
    // Den första ObjectsPoints-matrisen anses vara en bakgrundspoängmatris och 
    // den andra ObjectsPoints-matrisen anses vara en förgrundspunktsmatris.
    // När både DefaultObjectsRectangles och ObjectsRectangles i egenskapen Args för AutoMaskingArgs tillhandahålls, 
    // endast arrayen från Args används.
    options.Args = new AutoMaskingArgs()
    {
        ObjectsPoints = new Point[][]
                                                {
                                                    new Point[] { new Point(100, 100), new Point(150, 100) },
                                                    new Point[] { new Point(300, 200) },
                                                },
        ObjectsRectangles = new Rectangle[]
                                                    {
                                                        new Rectangle(100, 100, 300, 300),
                                                    }
    };

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

    // Sparar slutligt maskeringsresultat.
    using (RasterImage resultImage = (RasterImage)results[1].GetImage())
    {
        resultImage.Save(dataDir + "result6.png", new PngOptions() { ColorType = PngColorType.TruecolorWithAlpha });
    }
}



///<summary>
/// Returnera alla punkter som hör till de angivna rektanglarna.
///</summary>
///<param name="rectangles"> Uppsättningen av rektanglar.</param>
///<returns> Alla rektangelpunkter.</returns>
static Point[] GetRectanglePoints(params Rectangle[] rectangles)
{
    int arraySize = 0;
    foreach (Rectangle rectangle in rectangles)
    {
        arraySize += rectangle.Width * rectangle.Height;
    }

    Point[] pointArray = new Point[arraySize];
    int arrayIndex = 0;
    foreach (Rectangle rectangle in rectangles)
    {
       for (int x = rectangle.Left; x < rectangle.Right; x++)
        {
           for (int y = rectangle.Top; y < rectangle.Bottom; y++)
            {
                pointArray[arrayIndex++] = new Point(x, y);
            }
        }
    }

    return pointArray;
}


File.Delete(dataDir + "result.png");
File.Delete(dataDir + "result2.png");
File.Delete(dataDir + "result3.png");
File.Delete(dataDir + "result4.png");
File.Delete(dataDir + "result5.png");
File.Delete(dataDir + "result6.png");

Följande skärmdump visar ingångs- och utmatningsbilderna.

Grafklipp automatisk maskering med specificerade antagna objektdata

I den här tekniken används data för ett specifikt antaget objekt i egenskapen AssumedObjects i AutoMaskingGraphCutOptions, som används i efterföljande maskeringsiterationer. Följande kodavsnitt visar hur man använder grafklipps automatisk maskering med ett antaget objekt för att ta bort bakgrunden i en bild.

using Aspose.Imaging;
using Aspose.Imaging.FileFormats.Png;
using Aspose.Imaging.ImageOptions;
using Aspose.Imaging.Masking;
using Aspose.Imaging.Masking.Options;
using Aspose.Imaging.Masking.Result;
using Aspose.Imaging.Sources;
using System;
using System.Collections.Generic;
using System.IO;

string templatesFolder = @"c:\Users\USER\Downloads\templates\";
string dataDir = templatesFolder;

// För att förbättra maskeringsresultaten kan data för de specifika objekt som ska inkluderas i förgrundsmaskeringsresultatet tillhandahållas.
List<AssumedObjectData> assumedObjects = new List<AssumedObjectData>();
// Objekttypen och området som innehåller det objektet ska anges.
assumedObjects.Add(new AssumedObjectData(DetectedObjectType.Human, new Rectangle(0, 0, 256, 365)));

MaskingResult results;
using (RasterImage image = (RasterImage)Image.Load(dataDir + "couple.jpg"))
{
    // För att använda Graph Cut med automatiskt beräknade linjer, används AutoMaskingGraphCutOptions.
    AutoMaskingGraphCutOptions options = new AutoMaskingGraphCutOptions
    {
        AssumedObjects = assumedObjects,
        // 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(dataDir + "result.png")
                                                        },
        BackgroundReplacementColor = Color.Transparent
    };

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

    // Sparar slutligt maskeringsresultat.
    using (RasterImage resultImage = (RasterImage)results[1].GetImage())
    {
        resultImage.Save(dataDir + "result2.png", new PngOptions() { ColorType = PngColorType.TruecolorWithAlpha });
    }
}



File.Delete(dataDir + "result.png");
File.Delete(dataDir + "result2.png");

Följande skärmdump visar ingångs- och utmatningsbilderna.

Bildbakgrundsborttagning med manuell maskering

Om du inte är intresserad av automatisk maskering kan du använda manuell maskeringsmetod för att ta bort bakgrund från bilder. Följande kodavsnitt visar hur man tillämpar manuell maskering på en rasterbild för att ta bort bakgrunden.

using Aspose.Imaging;
using Aspose.Imaging.FileFormats.Png;
using Aspose.Imaging.ImageOptions;
using Aspose.Imaging.Masking;
using Aspose.Imaging.Masking.Options;
using Aspose.Imaging.Masking.Result;
using Aspose.Imaging.Shapes;
using Aspose.Imaging.Sources;
using System.IO;

string templatesFolder = @"c:\Users\USER\Downloads\templates\";
string dataDir = templatesFolder;

string sourceFileName = dataDir + "couple.png";
GraphicsPath manualMask = new GraphicsPath();
Figure firstFigure = new Figure();
firstFigure.AddShape(new EllipseShape(new RectangleF(100, 30, 40, 40)));
firstFigure.AddShape(new RectangleShape(new RectangleF(10, 200, 50, 30)));
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);
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(dataDir + "result.png", new PngOptions() { ColorType = PngColorType.TruecolorWithAlpha });
    }
}       

File.Delete(dataDir + "result.png");

Följande skärmdump visar ingångs- och utmatningsbilderna.

Skaffa C# Image Background Remover API

Du kan få en gratis tillfällig licens och använda vårt bibliotek för bildredigering och bakgrundsborttagning utan några begränsningar.

Slutsats

Att ta bort bakgrunder från bilder är en avgörande färdighet i bildredigering och design. Aspose.Imaging för .NET låter utvecklare exakt ta bort bakgrunder från bilder i C#-applikationer. Det här blogginlägget behandlade grunderna för att ladda bilder, implementera bakgrundsborttagning med olika metoder för automatisk och manuell maskering och att spara utdatabilden.

Genom att integrera Aspose.Imaging i dina C#-projekt kan du effektivisera arbetsflödet för bildbehandling och låsa upp en ny nivå av kreativitet i dina applikationer. Experimentera med olika funktioner och tekniker för att upptäcka den fulla potentialen hos Aspose.Imaging för .NET. Dela också dina frågor med oss via vårt forum.

Se även

• Vänd bilder i C#
• Ändra storlek på bilder i C#
• Rotera bilder i C#
• Beskär bilder i C#