Dans la création et la manipulation de contenu numérique, la suppression de l’arrière-plan des images est une tâche courante et essentielle. Que vous travailliez sur la conception graphique, le commerce électronique ou tout autre projet visuel, la possibilité d’isoler des objets de leur arrière-plan élargit votre créativité. Dans cet article de blog, nous explorerons comment supprimer l’arrière-plan des images par programmation en C#.
- Bibliothèque C# pour supprimer l’arrière-plan des images
- Suppression de l’arrière-plan de l’image avec le masquage automatique
- Suppression de l’arrière-plan à l’aide du masquage manuel
Bibliothèque C# pour supprimer l’arrière-plan des images
Pour supprimer l’arrière-plan des images, nous utiliserons Aspose.Imaging for .NET - une bibliothèque puissante qui fournit un large éventail de fonctionnalités de traitement d’image pour les applications .NET. Il prend en charge divers formats d’image et permet aux développeurs d’effectuer facilement des opérations telles que le redimensionnement, le recadrage, la rotation et, bien sûr, la suppression des arrière-plans.
Vous pouvez soit télécharger l’API, soit l’installer à partir de NuGet.
PM> Install-Package Aspose.Imaging
Suppression de l’arrière-plan de l’image avec masquage automatique en C#
Pour obtenir de meilleurs résultats de suppression d’arrière-plan, la méthode de masquage automatique est préférable. Le but est de créer un masque qui identifie avec précision les pixels appartenant au premier plan et ceux appartenant à l’arrière-plan. Aspose.Imaging propose trois techniques de masquage automatique pour supprimer l’arrière-plan de l’image, comme décrit dans les sections suivantes.
Masquage automatique de coupe graphique avec contour progressif
Dans cette technique, l’API effectue un masquage d’image avec un dégradé en fonction de la taille de l’image et utilise des traits par défaut calculés automatiquement. L’extrait de code suivant montre comment utiliser le masquage automatique de coupe graphique avec contour progressif. La propriété Args de AutoMaskingGraphCutOptions peut être omise puisque les traits par défaut y sont placés à la fin.
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"))
{
// 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(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");
La capture d’écran suivante montre les images d’entrée et de sortie.
Réutilisation des traits par défaut dans le masquage automatique répété
Dans cette technique, le masquage de l’image est effectué à l’aide de traits par défaut calculés automatiquement. Cependant, l’API réutilise les options de masquage pour la nouvelle itération de masquage. Dans l’extrait de code suivant, vous pouvez remarquer que les données des deux objets supposés sont également spécifiées dans la propriété AssumedObjects de AutoMaskingGraphCutOptions. Suite aux résultats de masquage initiaux, des ajustements sont apportés aux traits d’arrière-plan/premier plan appliqués, et une itération ultérieure de masquage est effectuée.
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;
// Pour améliorer les résultats de masquage, des données sur les objets spécifiques qui doivent être inclus dans le résultat de masquage de premier plan pourraient être fournies.
List<AssumedObjectData> assumedObjects = new List<AssumedObjectData>();
// Le type d'objet et la zone contenant cet objet doivent être spécifiés.
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"))
{
// Pour utiliser Graph Cut avec des traits calculés automatiquement, AutoMaskingGraphCutOptions est utilisé.
options = new AutoMaskingGraphCutOptions
{
AssumedObjects = assumedObjects,
// 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(dataDir + "result.png")
},
BackgroundReplacementColor = Color.Transparent
};
using (IMaskingSession maskingSession = new ImageMasking(image).CreateSession(options))
{
results = maskingSession.Decompose();
// Sauvegarde du résultat de masquage intermédiaire.
using (RasterImage resultImage = results[1].GetImage())
{
resultImage.Save(dataDir + "result2.png",
new PngOptions() { ColorType = PngColorType.TruecolorWithAlpha });
}
// À ce stade, les traits appliqués au premier plan/arrière-plan peuvent être analysés et basés sur ceux-ci.
// Les traits de premier plan/arrière-plan peuvent être fournis manuellement.
appliedBackgroundStrokes = options.DefaultBackgroundStrokes;
appliedForegroundStrokes = options.DefaultForegroundStrokes;
appliedObjectRectangles = options.DefaultObjectsRectangles;
// En réutilisant AutoMaskingGraphCutOptions, il n'est pas nécessaire d'effectuer une seconde fois les calculs de trait par défaut.
// Lorsque les traits par défaut et les ObjectsPoints dans la propriété Args de AutoMaskingArgs sont fournis, les tableaux de points sont finalement combinés.
// Le premier tableau ObjectsPoints est considéré comme un tableau de points d'arrière-plan et
// le deuxième tableau ObjectsPoints est considéré comme un tableau de points de premier plan.
// Lorsque les valeurs DefaultObjectsRectangles et ObjectsRectangles dans la propriété Args d'AutoMaskingArgs sont fournies,
// seul le tableau des Args est utilisé.
AutoMaskingArgs newAutoMaskingArgs = new AutoMaskingArgs()
{
ObjectsPoints = new Point[][]
{
// Spécifiant également les zones que nous souhaitons supprimer.
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 });
}
}
}
//Exemples - graphique - coupé - répété - masquage - avec - new- points.cs
// Pour améliorer les résultats de masquage, des données sur les objets spécifiques qui doivent être inclus dans le résultat de masquage de premier plan pourraient être fournies.
assumedObjects = new List<AssumedObjectData>();
// Le type d'objet et la zone contenant cet objet doivent être spécifiés.
assumedObjects.Add(new AssumedObjectData(DetectedObjectType.Human, new Rectangle(100, 100, 150, 300)));
// La première itération de masquage est effectuée pour obtenir des coups de pinceau de premier plan/arrière-plan calculés automatiquement.
using (RasterImage image = (RasterImage)Image.Load(dataDir + "couple.jpg"))
{
// Pour utiliser Graph Cut avec des traits calculés automatiquement, AutoMaskingGraphCutOptions est utilisé.
options = new AutoMaskingGraphCutOptions
{
AssumedObjects = assumedObjects,
// 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.
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);
// À ce stade, les traits appliqués au premier plan/arrière-plan peuvent être analysés et basés sur ceux-ci.
// Les traits de premier plan/arrière-plan peuvent être fournis manuellement.
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 });
}
}
// Une deuxième itération de masquage est effectuée pour améliorer encore la qualité du masquage en ajoutant de nouveaux points de premier plan/arrière-plan choisis manuellement.
using (RasterImage image = (RasterImage)Image.Load(dataDir + "couple.jpg"))
{
// En réutilisant AutoMaskingGraphCutOptions, il n'est pas nécessaire d'effectuer une seconde fois les calculs de trait par défaut.
options.CalculateDefaultStrokes = false;
// Lorsque les traits par défaut et les ObjectsPoints dans la propriété Args de AutoMaskingArgs sont fournis, les tableaux de points sont finalement combinés.
// Le premier tableau ObjectsPoints est considéré comme un tableau de points d'arrière-plan et
// le deuxième tableau ObjectsPoints est considéré comme un tableau de points de premier plan.
// Lorsque les valeurs DefaultObjectsRectangles et ObjectsRectangles dans la propriété Args d'AutoMaskingArgs sont fournies,
// seul le tableau des Args est utilisé.
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);
// Sauvegarde du résultat final du masquage.
using (RasterImage resultImage = (RasterImage)results[1].GetImage())
{
resultImage.Save(dataDir + "result6.png", new PngOptions() { ColorType = PngColorType.TruecolorWithAlpha });
}
}
///<summary>
/// Renvoie tous les points appartenant aux rectangles spécifiés.
///</summary>
///<param name="rectangles"> Le tableau de rectangles.</param>
///<returns> Tous les points du rectangle.</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");
La capture d’écran suivante montre les images d’entrée et de sortie.
Masquage automatique de coupe graphique avec les données d’objet supposées spécifiées
Dans cette technique, les données d’un objet supposé spécifique sont utilisées dans la propriété AssumedObjects de AutoMaskingGraphCutOptions, qui est utilisée dans les itérations de masquage ultérieures. L’extrait de code suivant montre comment utiliser le masquage automatique de coupe graphique avec un objet supposé pour supprimer l’arrière-plan d’une image.
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;
// Pour améliorer les résultats de masquage, des données sur les objets spécifiques qui doivent être inclus dans le résultat de masquage de premier plan pourraient être fournies.
List<AssumedObjectData> assumedObjects = new List<AssumedObjectData>();
// Le type d'objet et la zone contenant cet objet doivent être spécifiés.
assumedObjects.Add(new AssumedObjectData(DetectedObjectType.Human, new Rectangle(0, 0, 256, 365)));
MaskingResult results;
using (RasterImage image = (RasterImage)Image.Load(dataDir + "couple.jpg"))
{
// Pour utiliser Graph Cut avec des traits calculés automatiquement, AutoMaskingGraphCutOptions est utilisé.
AutoMaskingGraphCutOptions options = new AutoMaskingGraphCutOptions
{
AssumedObjects = assumedObjects,
// 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(dataDir + "result.png")
},
BackgroundReplacementColor = Color.Transparent
};
results = new ImageMasking(image).Decompose(options);
// Sauvegarde du résultat final du masquage.
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");
La capture d’écran suivante montre les images d’entrée et de sortie.
Suppression de l’arrière-plan de l’image à l’aide du masquage manuel
Si le masquage automatique ne vous intéresse pas, vous pouvez utiliser la méthode de masquage manuel pour supprimer l’arrière-plan des images. L’extrait de code suivant montre comment appliquer un masquage manuel à une image raster pour supprimer son arrière-plan.
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);
// Sauvegarde du résultat final du masquage.
using (RasterImage resultImage = (RasterImage)results[1].GetImage())
{
resultImage.Save(dataDir + "result.png", new PngOptions() { ColorType = PngColorType.TruecolorWithAlpha });
}
}
File.Delete(dataDir + "result.png");
La capture d’écran suivante montre les images d’entrée et de sortie.
Obtenez l’API de suppression d’arrière-plan d’image C#
Vous pouvez obtenir une licence temporaire gratuite et utiliser notre bibliothèque d’édition d’images et de suppression d’arrière-plan sans aucune limitation.
Conclusion
La suppression des arrière-plans des images est une compétence cruciale dans l’édition et la conception d’images. Aspose.Imaging for .NET permet aux développeurs de supprimer avec précision les arrière-plans des images dans les applications C#. Cet article de blog couvre les bases du chargement d’images, de la mise en œuvre de la suppression de l’arrière-plan à l’aide de différentes méthodes de masquage automatique et manuel et de l’enregistrement de l’image de sortie.
En intégrant Aspose.Imaging dans vos projets C#, vous pouvez rationaliser le flux de travail de traitement d’image et débloquer un nouveau niveau de créativité dans vos applications. Expérimentez avec différentes fonctionnalités et techniques pour découvrir tout le potentiel d’Aspose.Imaging for .NET. Partagez également vos questions avec nous via notre forum.