Class MaskingOptions
Class MaskingOptions
Namespace: Aspose.Imaging.Masking.Options
Assembly: Aspose.Imaging.dll (25.2.0)
Represents the common image masking options.
public class MaskingOptionsInheritance
Derived
Inherited Members
object.GetType(), object.MemberwiseClone(), object.ToString(), object.Equals(object?), object.Equals(object?, object?), object.ReferenceEquals(object?, object?), object.GetHashCode()
Examples
This example shows how to decompose a raster image into multiple images using image masking and the K-means segmentation algorithm. Image masking is an image processing technique that is used to split the background from the foreground image objects.```csharp [C#]
string dir = "c:\\temp\\";
using (Aspose.Imaging.RasterImage image = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "Blue hills.png"))
{
Aspose.Imaging.Masking.Options.AutoMaskingArgs args = new Aspose.Imaging.Masking.Options.AutoMaskingArgs();
// Set the number of clusters (separated objects). The default value is 2, the foreground object and the background.
args.NumberOfObjects = 3;
// Set the maximum number of iterations.
args.MaxIterationNumber = 50;
// Set the precision of segmentation method (optional)
args.Precision = 1;
// Each cluster (segment) will be stored to a separate PNG file.
Aspose.Imaging.ImageOptions.PngOptions exportOptions = new Aspose.Imaging.ImageOptions.PngOptions();
exportOptions.ColorType = Aspose.Imaging.FileFormats.Png.PngColorType.TruecolorWithAlpha;
exportOptions.Source = new Aspose.Imaging.Sources.StreamSource(new System.IO.MemoryStream());
Aspose.Imaging.Masking.Options.MaskingOptions maskingOptions = new Aspose.Imaging.Masking.Options.MaskingOptions();
// Use K-means clustering.
// K-means clustering allows to split image into several independent clusters (segments).
maskingOptions.Method = Masking.Options.SegmentationMethod.KMeans;
maskingOptions.Decompose = true;
maskingOptions.Args = args;
// The backgroung color will be orange.
maskingOptions.BackgroundReplacementColor = Aspose.Imaging.Color.Orange;
maskingOptions.ExportOptions = exportOptions;
// Create an instance of the ImageMasking class.
Aspose.Imaging.Masking.ImageMasking masking = new Aspose.Imaging.Masking.ImageMasking(image);
// Divide the source image into several clusters (segments).
using (Aspose.Imaging.Masking.Result.MaskingResult maskingResult = masking.Decompose(maskingOptions))
{
// Obtain images from masking result and save them to PNG.
for (int i = 0; i < maskingResult.Length; i++)
{
string outputFileName = string.Format("Blue hills.Segment{0}.png", maskingResult[i].ObjectNumber);
using (Aspose.Imaging.Image resultImage = maskingResult[i].GetImage())
{
resultImage.Save(dir + outputFileName);
}
}
}
}
Using a segment mask to speed up the segmentation process```csharp
[C#]
// Masking export options
Aspose.Imaging.ImageOptions.PngOptions exportOptions = new Aspose.Imaging.ImageOptions.PngOptions();
exportOptions.ColorType = Aspose.Imaging.FileFormats.Png.PngColorType.TruecolorWithAlpha;
exportOptions.Source = new Aspose.Imaging.Sources.StreamSource(new System.IO.MemoryStream());
Aspose.Imaging.Masking.Options.MaskingOptions maskingOptions = new Aspose.Imaging.Masking.Options.MaskingOptions();
// Use GraphCut clustering.
maskingOptions.Method = Masking.Options.SegmentationMethod.GraphCut;
maskingOptions.Decompose = false;
maskingOptions.Args = new Aspose.Imaging.Masking.Options.AutoMaskingArgs();
// The backgroung color will be transparent.
maskingOptions.BackgroundReplacementColor = Aspose.Imaging.Color.Transparent;
maskingOptions.ExportOptions = exportOptions;
string dir = "c:\\temp\\";
using (Aspose.Imaging.RasterImage image = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "BigImage.jpg"))
{
Aspose.Imaging.Size imageSize = image.Size;
// Reducing image size to speed up the segmentation process
image.ResizeHeightProportionally(600, Aspose.Imaging.ResizeType.HighQualityResample);
// Create an instance of the ImageMasking class.
Aspose.Imaging.Masking.ImageMasking masking = new Aspose.Imaging.Masking.ImageMasking(image);
// Divide the source image into several clusters (segments).
using (Aspose.Imaging.Masking.Result.MaskingResult maskingResult = masking.Decompose(maskingOptions))
{
// Getting the foreground mask
using (Aspose.Imaging.RasterImage foregroundMask = maskingResult[1].GetMask())
{
// Increase the size of the mask to the size of the original image
foregroundMask.Resize(imageSize.Width, imageSize.Height, Aspose.Imaging.ResizeType.NearestNeighbourResample);
// Applying the mask to the original image to obtain a foreground segment
using (Aspose.Imaging.RasterImage originImage = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "BigImage.jpg"))
{
Aspose.Imaging.Masking.ImageMasking.ApplyMask(originImage, foregroundMask, maskingOptions);
originImage.Save(dir + "BigImage_foreground.png", exportOptions);
}
}
}
}This example shows how to decompose a raster image into multiple images using image masking and a manual mask. Image masking is an image processing technique that is used to split the background from the foreground image objects.```csharp [C#]
string dir = "c:\\temp\\";
// Define a manual mask.
Aspose.Imaging.GraphicsPath manualMask = new Aspose.Imaging.GraphicsPath();
Aspose.Imaging.Figure figure = new Aspose.Imaging.Figure();
figure.AddShape(new Aspose.Imaging.Shapes.EllipseShape(new RectangleF(50, 50, 40, 40)));
figure.AddShape(new Aspose.Imaging.Shapes.RectangleShape(new RectangleF(10, 20, 50, 30)));
manualMask.AddFigure(figure);
// Each cluster (segment) will be stored to a separate PNG file.
Aspose.Imaging.ImageOptions.PngOptions exportOptions = new Aspose.Imaging.ImageOptions.PngOptions();
exportOptions.ColorType = Aspose.Imaging.FileFormats.Png.PngColorType.TruecolorWithAlpha;
exportOptions.Source = new Aspose.Imaging.Sources.StreamSource(new System.IO.MemoryStream());
// Set the manual mask.
Aspose.Imaging.Masking.Options.ManualMaskingArgs args = new Aspose.Imaging.Masking.Options.ManualMaskingArgs();
args.Mask = manualMask;
using (RasterImage image = (RasterImage)Image.Load(dir + "Blue hills.png"))
{
Aspose.Imaging.Masking.Options.MaskingOptions maskingOptions = new Aspose.Imaging.Masking.Options.MaskingOptions();
// Use manual clustering algorithm.
maskingOptions.Method = Masking.Options.SegmentationMethod.Manual;
// All shapes making up a mask will be combined into one.
maskingOptions.Decompose = false;
maskingOptions.Args = args;
// The backgroung color will be orange.
maskingOptions.BackgroundReplacementColor = Aspose.Imaging.Color.Orange;
maskingOptions.ExportOptions = exportOptions;
// The area of the source image that masking will be applied to.
maskingOptions.MaskingArea = new Rectangle(50, 50, 120, 120);
// Create an instance of the ImageMasking class.
Aspose.Imaging.Masking.ImageMasking masking = new Aspose.Imaging.Masking.ImageMasking(image);
// Divide the source image into several clusters (segments).
using (Aspose.Imaging.Masking.Result.MaskingResult maskingResult = masking.Decompose(maskingOptions))
{
// Obtain images from masking result and save them to PNG.
for (int i = 0; i < maskingResult.Length; i++)
{
string outputFileName = string.Format("Blue hills.Segment{0}.png", maskingResult[i].ObjectNumber);
using (Aspose.Imaging.Image resultImage = maskingResult[i].GetImage())
{
resultImage.Save(dir + outputFileName);
}
}
}
}
This example shows how to specify suggestions for image masking algorithm to improve precision of segmentation (clustering) method. Image masking is an image processing technique that is used to split the background from the foreground image objects.```csharp
[C#]
string dir = "c:\\temp\\";
using (Aspose.Imaging.RasterImage image = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "Gorilla.bmp"))
{
Aspose.Imaging.Masking.Options.AutoMaskingArgs args = new Aspose.Imaging.Masking.Options.AutoMaskingArgs();
// Suggestion #1.
// Analyze the image visually and set the area of interest. The result of segmentation will include only objects that will be completely located within this area.
args.ObjectsRectangles = new Rectangle[]
{
new Rectangle(86, 6, 270, 364),
};
// Suggestion #2.
// Analyze the image visually and set the points that belong to separated objects.
args.ObjectsPoints = new Point[][]
{
new Point[] { new Point(103, 326) },
new Point[] { new Point(280, 43) },
new Point[] { new Point(319, 86) },
};
// Each cluster (segment) will be stored to a separate PNG file.
Aspose.Imaging.ImageOptions.PngOptions exportOptions = new Aspose.Imaging.ImageOptions.PngOptions();
exportOptions.ColorType = Aspose.Imaging.FileFormats.Png.PngColorType.TruecolorWithAlpha;
exportOptions.Source = new Aspose.Imaging.Sources.StreamSource(new System.IO.MemoryStream());
Aspose.Imaging.Masking.Options.MaskingOptions maskingOptions = new Aspose.Imaging.Masking.Options.MaskingOptions();
// Use GraphCut clustering.
maskingOptions.Method = Masking.Options.SegmentationMethod.GraphCut;
maskingOptions.Decompose = false;
maskingOptions.Args = args;
// The backgroung color will be orange.
maskingOptions.BackgroundReplacementColor = Aspose.Imaging.Color.Orange;
maskingOptions.ExportOptions = exportOptions;
// Create an instance of the ImageMasking class.
Aspose.Imaging.Masking.ImageMasking masking = new Aspose.Imaging.Masking.ImageMasking(image);
// Divide the source image into several clusters (segments).
using (Aspose.Imaging.Masking.Result.MaskingResult maskingResult = masking.Decompose(maskingOptions))
{
// Obtain images from masking result and save them to PNG.
for (int i = 0; i < maskingResult.Length; i++)
{
string outputFileName = string.Format("Gorilla.Segment{0}.png", maskingResult[i].ObjectNumber);
using (Aspose.Imaging.Image resultImage = maskingResult[i].GetImage())
{
resultImage.Save(dir + outputFileName);
}
}
}
}Saving the masking session to a file for long sessions, as well as for the possibility of resuming the session in another environment.```csharp [C#]
string dir = "c:\\temp\\";
string sessionBackupFile = dir + "session.bak";
// Masking export options
Aspose.Imaging.ImageOptions.PngOptions exportOptions = new Aspose.Imaging.ImageOptions.PngOptions();
exportOptions.ColorType = Aspose.Imaging.FileFormats.Png.PngColorType.TruecolorWithAlpha;
exportOptions.Source = new Aspose.Imaging.Sources.StreamSource(new System.IO.MemoryStream());
Aspose.Imaging.Masking.Options.MaskingOptions maskingOptions = new Aspose.Imaging.Masking.Options.MaskingOptions();
// Use GraphCut clustering.
maskingOptions.Method = Masking.Options.SegmentationMethod.GraphCut;
maskingOptions.Decompose = false;
maskingOptions.Args = new Aspose.Imaging.Masking.Options.AutoMaskingArgs();
// The backgroung color will be orange.
maskingOptions.BackgroundReplacementColor = Aspose.Imaging.Color.Orange;
maskingOptions.ExportOptions = exportOptions;
// Starting a session for the first time and saving to a file
using (Aspose.Imaging.RasterImage image = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "Gorilla.bmp"))
{
// Create an instance of the ImageMasking class.
Aspose.Imaging.Masking.ImageMasking masking = new Aspose.Imaging.Masking.ImageMasking(image);
using (Aspose.Imaging.Masking.IMaskingSession session = masking.CreateSession(maskingOptions))
{
using (Aspose.Imaging.Masking.Result.MaskingResult maskingResult = session.Decompose())
{
using (Aspose.Imaging.RasterImage segmentImage = maskingResult[1].GetImage())
{
segmentImage.Save(dir + "step1.png");
}
}
session.Save(sessionBackupFile);
}
}
// Resuming a masking session from a file
using (Aspose.Imaging.RasterImage image = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "Gorilla.bmp"))
{
// Create an instance of the ImageMasking class.
Aspose.Imaging.Masking.ImageMasking masking = new Aspose.Imaging.Masking.ImageMasking(image);
using (Aspose.Imaging.Masking.IMaskingSession session = masking.LoadSession(sessionBackupFile))
{
Aspose.Imaging.Masking.Options.AutoMaskingArgs args = new Aspose.Imaging.Masking.Options.AutoMaskingArgs();
// Analyze the image visually and set the points that belong to separated objects.
args.ObjectsPoints = new Point[][]
{
new Point[]
{
new Point(0, 0), new Point(0, 1), new Point(1, 0),
new Point(1, 1), new Point(2, 0), new Point(2, 1),
new Point(3, 0), new Point(3, 1)
},
};
using (Aspose.Imaging.Masking.Result.MaskingResult maskingResult = session.ImproveDecomposition(args))
{
// Explicit transfer of export options, since it is not serializable
maskingResult.MaskingOptions.ExportOptions = exportOptions;
using (Aspose.Imaging.RasterImage segmentImage = maskingResult[1].GetImage())
{
segmentImage.Save(dir + "step2.png");
}
}
}
}
## Constructors
### <a id="Aspose_Imaging_Masking_Options_MaskingOptions__ctor"></a> MaskingOptions\(\)
```csharp
public MaskingOptions()Fields
BackgroundObjectNumber
The background object number
public const int BackgroundObjectNumber = 0Field Value
Properties
Args
Gets or sets the arguments for segmentation algorithm.
public IMaskingArgs Args { get; set; }Property Value
Examples
This example shows how to decompose a raster image into multiple images using image masking and the K-means segmentation algorithm. Image masking is an image processing technique that is used to split the background from the foreground image objects.```csharp [C#]
string dir = "c:\\temp\\";
using (Aspose.Imaging.RasterImage image = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "Blue hills.png"))
{
Aspose.Imaging.Masking.Options.AutoMaskingArgs args = new Aspose.Imaging.Masking.Options.AutoMaskingArgs();
// Set the number of clusters (separated objects). The default value is 2, the foreground object and the background.
args.NumberOfObjects = 3;
// Set the maximum number of iterations.
args.MaxIterationNumber = 50;
// Set the precision of segmentation method (optional)
args.Precision = 1;
// Each cluster (segment) will be stored to a separate PNG file.
Aspose.Imaging.ImageOptions.PngOptions exportOptions = new Aspose.Imaging.ImageOptions.PngOptions();
exportOptions.ColorType = Aspose.Imaging.FileFormats.Png.PngColorType.TruecolorWithAlpha;
exportOptions.Source = new Aspose.Imaging.Sources.StreamSource(new System.IO.MemoryStream());
Aspose.Imaging.Masking.Options.MaskingOptions maskingOptions = new Aspose.Imaging.Masking.Options.MaskingOptions();
// Use K-means clustering.
// K-means clustering allows to split image into several independent clusters (segments).
maskingOptions.Method = Masking.Options.SegmentationMethod.KMeans;
maskingOptions.Decompose = true;
maskingOptions.Args = args;
// The backgroung color will be orange.
maskingOptions.BackgroundReplacementColor = Aspose.Imaging.Color.Orange;
maskingOptions.ExportOptions = exportOptions;
// Create an instance of the ImageMasking class.
Aspose.Imaging.Masking.ImageMasking masking = new Aspose.Imaging.Masking.ImageMasking(image);
// Divide the source image into several clusters (segments).
using (Aspose.Imaging.Masking.Result.MaskingResult maskingResult = masking.Decompose(maskingOptions))
{
// Obtain images from masking result and save them to PNG.
for (int i = 0; i < maskingResult.Length; i++)
{
string outputFileName = string.Format("Blue hills.Segment{0}.png", maskingResult[i].ObjectNumber);
using (Aspose.Imaging.Image resultImage = maskingResult[i].GetImage())
{
resultImage.Save(dir + outputFileName);
}
}
}
}
Using a segment mask to speed up the segmentation process```csharp
[C#]
// Masking export options
Aspose.Imaging.ImageOptions.PngOptions exportOptions = new Aspose.Imaging.ImageOptions.PngOptions();
exportOptions.ColorType = Aspose.Imaging.FileFormats.Png.PngColorType.TruecolorWithAlpha;
exportOptions.Source = new Aspose.Imaging.Sources.StreamSource(new System.IO.MemoryStream());
Aspose.Imaging.Masking.Options.MaskingOptions maskingOptions = new Aspose.Imaging.Masking.Options.MaskingOptions();
// Use GraphCut clustering.
maskingOptions.Method = Masking.Options.SegmentationMethod.GraphCut;
maskingOptions.Decompose = false;
maskingOptions.Args = new Aspose.Imaging.Masking.Options.AutoMaskingArgs();
// The backgroung color will be transparent.
maskingOptions.BackgroundReplacementColor = Aspose.Imaging.Color.Transparent;
maskingOptions.ExportOptions = exportOptions;
string dir = "c:\\temp\\";
using (Aspose.Imaging.RasterImage image = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "BigImage.jpg"))
{
Aspose.Imaging.Size imageSize = image.Size;
// Reducing image size to speed up the segmentation process
image.ResizeHeightProportionally(600, Aspose.Imaging.ResizeType.HighQualityResample);
// Create an instance of the ImageMasking class.
Aspose.Imaging.Masking.ImageMasking masking = new Aspose.Imaging.Masking.ImageMasking(image);
// Divide the source image into several clusters (segments).
using (Aspose.Imaging.Masking.Result.MaskingResult maskingResult = masking.Decompose(maskingOptions))
{
// Getting the foreground mask
using (Aspose.Imaging.RasterImage foregroundMask = maskingResult[1].GetMask())
{
// Increase the size of the mask to the size of the original image
foregroundMask.Resize(imageSize.Width, imageSize.Height, Aspose.Imaging.ResizeType.NearestNeighbourResample);
// Applying the mask to the original image to obtain a foreground segment
using (Aspose.Imaging.RasterImage originImage = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "BigImage.jpg"))
{
Aspose.Imaging.Masking.ImageMasking.ApplyMask(originImage, foregroundMask, maskingOptions);
originImage.Save(dir + "BigImage_foreground.png", exportOptions);
}
}
}
}This example shows how to decompose a raster image into multiple images using image masking and a manual mask. Image masking is an image processing technique that is used to split the background from the foreground image objects.```csharp [C#]
string dir = "c:\\temp\\";
// Define a manual mask.
Aspose.Imaging.GraphicsPath manualMask = new Aspose.Imaging.GraphicsPath();
Aspose.Imaging.Figure figure = new Aspose.Imaging.Figure();
figure.AddShape(new Aspose.Imaging.Shapes.EllipseShape(new RectangleF(50, 50, 40, 40)));
figure.AddShape(new Aspose.Imaging.Shapes.RectangleShape(new RectangleF(10, 20, 50, 30)));
manualMask.AddFigure(figure);
// Each cluster (segment) will be stored to a separate PNG file.
Aspose.Imaging.ImageOptions.PngOptions exportOptions = new Aspose.Imaging.ImageOptions.PngOptions();
exportOptions.ColorType = Aspose.Imaging.FileFormats.Png.PngColorType.TruecolorWithAlpha;
exportOptions.Source = new Aspose.Imaging.Sources.StreamSource(new System.IO.MemoryStream());
// Set the manual mask.
Aspose.Imaging.Masking.Options.ManualMaskingArgs args = new Aspose.Imaging.Masking.Options.ManualMaskingArgs();
args.Mask = manualMask;
using (RasterImage image = (RasterImage)Image.Load(dir + "Blue hills.png"))
{
Aspose.Imaging.Masking.Options.MaskingOptions maskingOptions = new Aspose.Imaging.Masking.Options.MaskingOptions();
// Use manual clustering algorithm.
maskingOptions.Method = Masking.Options.SegmentationMethod.Manual;
// All shapes making up a mask will be combined into one.
maskingOptions.Decompose = false;
maskingOptions.Args = args;
// The backgroung color will be orange.
maskingOptions.BackgroundReplacementColor = Aspose.Imaging.Color.Orange;
maskingOptions.ExportOptions = exportOptions;
// The area of the source image that masking will be applied to.
maskingOptions.MaskingArea = new Rectangle(50, 50, 120, 120);
// Create an instance of the ImageMasking class.
Aspose.Imaging.Masking.ImageMasking masking = new Aspose.Imaging.Masking.ImageMasking(image);
// Divide the source image into several clusters (segments).
using (Aspose.Imaging.Masking.Result.MaskingResult maskingResult = masking.Decompose(maskingOptions))
{
// Obtain images from masking result and save them to PNG.
for (int i = 0; i < maskingResult.Length; i++)
{
string outputFileName = string.Format("Blue hills.Segment{0}.png", maskingResult[i].ObjectNumber);
using (Aspose.Imaging.Image resultImage = maskingResult[i].GetImage())
{
resultImage.Save(dir + outputFileName);
}
}
}
}
This example shows how to specify suggestions for image masking algorithm to improve precision of segmentation (clustering) method. Image masking is an image processing technique that is used to split the background from the foreground image objects.```csharp
[C#]
string dir = "c:\\temp\\";
using (Aspose.Imaging.RasterImage image = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "Gorilla.bmp"))
{
Aspose.Imaging.Masking.Options.AutoMaskingArgs args = new Aspose.Imaging.Masking.Options.AutoMaskingArgs();
// Suggestion #1.
// Analyze the image visually and set the area of interest. The result of segmentation will include only objects that will be completely located within this area.
args.ObjectsRectangles = new Rectangle[]
{
new Rectangle(86, 6, 270, 364),
};
// Suggestion #2.
// Analyze the image visually and set the points that belong to separated objects.
args.ObjectsPoints = new Point[][]
{
new Point[] { new Point(103, 326) },
new Point[] { new Point(280, 43) },
new Point[] { new Point(319, 86) },
};
// Each cluster (segment) will be stored to a separate PNG file.
Aspose.Imaging.ImageOptions.PngOptions exportOptions = new Aspose.Imaging.ImageOptions.PngOptions();
exportOptions.ColorType = Aspose.Imaging.FileFormats.Png.PngColorType.TruecolorWithAlpha;
exportOptions.Source = new Aspose.Imaging.Sources.StreamSource(new System.IO.MemoryStream());
Aspose.Imaging.Masking.Options.MaskingOptions maskingOptions = new Aspose.Imaging.Masking.Options.MaskingOptions();
// Use GraphCut clustering.
maskingOptions.Method = Masking.Options.SegmentationMethod.GraphCut;
maskingOptions.Decompose = false;
maskingOptions.Args = args;
// The backgroung color will be orange.
maskingOptions.BackgroundReplacementColor = Aspose.Imaging.Color.Orange;
maskingOptions.ExportOptions = exportOptions;
// Create an instance of the ImageMasking class.
Aspose.Imaging.Masking.ImageMasking masking = new Aspose.Imaging.Masking.ImageMasking(image);
// Divide the source image into several clusters (segments).
using (Aspose.Imaging.Masking.Result.MaskingResult maskingResult = masking.Decompose(maskingOptions))
{
// Obtain images from masking result and save them to PNG.
for (int i = 0; i < maskingResult.Length; i++)
{
string outputFileName = string.Format("Gorilla.Segment{0}.png", maskingResult[i].ObjectNumber);
using (Aspose.Imaging.Image resultImage = maskingResult[i].GetImage())
{
resultImage.Save(dir + outputFileName);
}
}
}
}Saving the masking session to a file for long sessions, as well as for the possibility of resuming the session in another environment.```csharp [C#]
string dir = "c:\\temp\\";
string sessionBackupFile = dir + "session.bak";
// Masking export options
Aspose.Imaging.ImageOptions.PngOptions exportOptions = new Aspose.Imaging.ImageOptions.PngOptions();
exportOptions.ColorType = Aspose.Imaging.FileFormats.Png.PngColorType.TruecolorWithAlpha;
exportOptions.Source = new Aspose.Imaging.Sources.StreamSource(new System.IO.MemoryStream());
Aspose.Imaging.Masking.Options.MaskingOptions maskingOptions = new Aspose.Imaging.Masking.Options.MaskingOptions();
// Use GraphCut clustering.
maskingOptions.Method = Masking.Options.SegmentationMethod.GraphCut;
maskingOptions.Decompose = false;
maskingOptions.Args = new Aspose.Imaging.Masking.Options.AutoMaskingArgs();
// The backgroung color will be orange.
maskingOptions.BackgroundReplacementColor = Aspose.Imaging.Color.Orange;
maskingOptions.ExportOptions = exportOptions;
// Starting a session for the first time and saving to a file
using (Aspose.Imaging.RasterImage image = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "Gorilla.bmp"))
{
// Create an instance of the ImageMasking class.
Aspose.Imaging.Masking.ImageMasking masking = new Aspose.Imaging.Masking.ImageMasking(image);
using (Aspose.Imaging.Masking.IMaskingSession session = masking.CreateSession(maskingOptions))
{
using (Aspose.Imaging.Masking.Result.MaskingResult maskingResult = session.Decompose())
{
using (Aspose.Imaging.RasterImage segmentImage = maskingResult[1].GetImage())
{
segmentImage.Save(dir + "step1.png");
}
}
session.Save(sessionBackupFile);
}
}
// Resuming a masking session from a file
using (Aspose.Imaging.RasterImage image = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "Gorilla.bmp"))
{
// Create an instance of the ImageMasking class.
Aspose.Imaging.Masking.ImageMasking masking = new Aspose.Imaging.Masking.ImageMasking(image);
using (Aspose.Imaging.Masking.IMaskingSession session = masking.LoadSession(sessionBackupFile))
{
Aspose.Imaging.Masking.Options.AutoMaskingArgs args = new Aspose.Imaging.Masking.Options.AutoMaskingArgs();
// Analyze the image visually and set the points that belong to separated objects.
args.ObjectsPoints = new Point[][]
{
new Point[]
{
new Point(0, 0), new Point(0, 1), new Point(1, 0),
new Point(1, 1), new Point(2, 0), new Point(2, 1),
new Point(3, 0), new Point(3, 1)
},
};
using (Aspose.Imaging.Masking.Result.MaskingResult maskingResult = session.ImproveDecomposition(args))
{
// Explicit transfer of export options, since it is not serializable
maskingResult.MaskingOptions.ExportOptions = exportOptions;
using (Aspose.Imaging.RasterImage segmentImage = maskingResult[1].GetImage())
{
segmentImage.Save(dir + "step2.png");
}
}
}
}
### <a id="Aspose_Imaging_Masking_Options_MaskingOptions_BackgroundReplacementColor"></a> BackgroundReplacementColor
Gets or sets the background replacement color.
```csharp
public Color BackgroundReplacementColor { get; set; }Property Value
Examples
This example shows how to decompose a raster image into multiple images using image masking and the K-means segmentation algorithm. Image masking is an image processing technique that is used to split the background from the foreground image objects.```csharp [C#]
string dir = "c:\\temp\\";
using (Aspose.Imaging.RasterImage image = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "Blue hills.png"))
{
Aspose.Imaging.Masking.Options.AutoMaskingArgs args = new Aspose.Imaging.Masking.Options.AutoMaskingArgs();
// Set the number of clusters (separated objects). The default value is 2, the foreground object and the background.
args.NumberOfObjects = 3;
// Set the maximum number of iterations.
args.MaxIterationNumber = 50;
// Set the precision of segmentation method (optional)
args.Precision = 1;
// Each cluster (segment) will be stored to a separate PNG file.
Aspose.Imaging.ImageOptions.PngOptions exportOptions = new Aspose.Imaging.ImageOptions.PngOptions();
exportOptions.ColorType = Aspose.Imaging.FileFormats.Png.PngColorType.TruecolorWithAlpha;
exportOptions.Source = new Aspose.Imaging.Sources.StreamSource(new System.IO.MemoryStream());
Aspose.Imaging.Masking.Options.MaskingOptions maskingOptions = new Aspose.Imaging.Masking.Options.MaskingOptions();
// Use K-means clustering.
// K-means clustering allows to split image into several independent clusters (segments).
maskingOptions.Method = Masking.Options.SegmentationMethod.KMeans;
maskingOptions.Decompose = true;
maskingOptions.Args = args;
// The backgroung color will be orange.
maskingOptions.BackgroundReplacementColor = Aspose.Imaging.Color.Orange;
maskingOptions.ExportOptions = exportOptions;
// Create an instance of the ImageMasking class.
Aspose.Imaging.Masking.ImageMasking masking = new Aspose.Imaging.Masking.ImageMasking(image);
// Divide the source image into several clusters (segments).
using (Aspose.Imaging.Masking.Result.MaskingResult maskingResult = masking.Decompose(maskingOptions))
{
// Obtain images from masking result and save them to PNG.
for (int i = 0; i < maskingResult.Length; i++)
{
string outputFileName = string.Format("Blue hills.Segment{0}.png", maskingResult[i].ObjectNumber);
using (Aspose.Imaging.Image resultImage = maskingResult[i].GetImage())
{
resultImage.Save(dir + outputFileName);
}
}
}
}
Using a segment mask to speed up the segmentation process```csharp
[C#]
// Masking export options
Aspose.Imaging.ImageOptions.PngOptions exportOptions = new Aspose.Imaging.ImageOptions.PngOptions();
exportOptions.ColorType = Aspose.Imaging.FileFormats.Png.PngColorType.TruecolorWithAlpha;
exportOptions.Source = new Aspose.Imaging.Sources.StreamSource(new System.IO.MemoryStream());
Aspose.Imaging.Masking.Options.MaskingOptions maskingOptions = new Aspose.Imaging.Masking.Options.MaskingOptions();
// Use GraphCut clustering.
maskingOptions.Method = Masking.Options.SegmentationMethod.GraphCut;
maskingOptions.Decompose = false;
maskingOptions.Args = new Aspose.Imaging.Masking.Options.AutoMaskingArgs();
// The backgroung color will be transparent.
maskingOptions.BackgroundReplacementColor = Aspose.Imaging.Color.Transparent;
maskingOptions.ExportOptions = exportOptions;
string dir = "c:\\temp\\";
using (Aspose.Imaging.RasterImage image = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "BigImage.jpg"))
{
Aspose.Imaging.Size imageSize = image.Size;
// Reducing image size to speed up the segmentation process
image.ResizeHeightProportionally(600, Aspose.Imaging.ResizeType.HighQualityResample);
// Create an instance of the ImageMasking class.
Aspose.Imaging.Masking.ImageMasking masking = new Aspose.Imaging.Masking.ImageMasking(image);
// Divide the source image into several clusters (segments).
using (Aspose.Imaging.Masking.Result.MaskingResult maskingResult = masking.Decompose(maskingOptions))
{
// Getting the foreground mask
using (Aspose.Imaging.RasterImage foregroundMask = maskingResult[1].GetMask())
{
// Increase the size of the mask to the size of the original image
foregroundMask.Resize(imageSize.Width, imageSize.Height, Aspose.Imaging.ResizeType.NearestNeighbourResample);
// Applying the mask to the original image to obtain a foreground segment
using (Aspose.Imaging.RasterImage originImage = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "BigImage.jpg"))
{
Aspose.Imaging.Masking.ImageMasking.ApplyMask(originImage, foregroundMask, maskingOptions);
originImage.Save(dir + "BigImage_foreground.png", exportOptions);
}
}
}
}This example shows how to decompose a raster image into multiple images using image masking and a manual mask. Image masking is an image processing technique that is used to split the background from the foreground image objects.```csharp [C#]
string dir = "c:\\temp\\";
// Define a manual mask.
Aspose.Imaging.GraphicsPath manualMask = new Aspose.Imaging.GraphicsPath();
Aspose.Imaging.Figure figure = new Aspose.Imaging.Figure();
figure.AddShape(new Aspose.Imaging.Shapes.EllipseShape(new RectangleF(50, 50, 40, 40)));
figure.AddShape(new Aspose.Imaging.Shapes.RectangleShape(new RectangleF(10, 20, 50, 30)));
manualMask.AddFigure(figure);
// Each cluster (segment) will be stored to a separate PNG file.
Aspose.Imaging.ImageOptions.PngOptions exportOptions = new Aspose.Imaging.ImageOptions.PngOptions();
exportOptions.ColorType = Aspose.Imaging.FileFormats.Png.PngColorType.TruecolorWithAlpha;
exportOptions.Source = new Aspose.Imaging.Sources.StreamSource(new System.IO.MemoryStream());
// Set the manual mask.
Aspose.Imaging.Masking.Options.ManualMaskingArgs args = new Aspose.Imaging.Masking.Options.ManualMaskingArgs();
args.Mask = manualMask;
using (RasterImage image = (RasterImage)Image.Load(dir + "Blue hills.png"))
{
Aspose.Imaging.Masking.Options.MaskingOptions maskingOptions = new Aspose.Imaging.Masking.Options.MaskingOptions();
// Use manual clustering algorithm.
maskingOptions.Method = Masking.Options.SegmentationMethod.Manual;
// All shapes making up a mask will be combined into one.
maskingOptions.Decompose = false;
maskingOptions.Args = args;
// The backgroung color will be orange.
maskingOptions.BackgroundReplacementColor = Aspose.Imaging.Color.Orange;
maskingOptions.ExportOptions = exportOptions;
// The area of the source image that masking will be applied to.
maskingOptions.MaskingArea = new Rectangle(50, 50, 120, 120);
// Create an instance of the ImageMasking class.
Aspose.Imaging.Masking.ImageMasking masking = new Aspose.Imaging.Masking.ImageMasking(image);
// Divide the source image into several clusters (segments).
using (Aspose.Imaging.Masking.Result.MaskingResult maskingResult = masking.Decompose(maskingOptions))
{
// Obtain images from masking result and save them to PNG.
for (int i = 0; i < maskingResult.Length; i++)
{
string outputFileName = string.Format("Blue hills.Segment{0}.png", maskingResult[i].ObjectNumber);
using (Aspose.Imaging.Image resultImage = maskingResult[i].GetImage())
{
resultImage.Save(dir + outputFileName);
}
}
}
}
This example shows how to specify suggestions for image masking algorithm to improve precision of segmentation (clustering) method. Image masking is an image processing technique that is used to split the background from the foreground image objects.```csharp
[C#]
string dir = "c:\\temp\\";
using (Aspose.Imaging.RasterImage image = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "Gorilla.bmp"))
{
Aspose.Imaging.Masking.Options.AutoMaskingArgs args = new Aspose.Imaging.Masking.Options.AutoMaskingArgs();
// Suggestion #1.
// Analyze the image visually and set the area of interest. The result of segmentation will include only objects that will be completely located within this area.
args.ObjectsRectangles = new Rectangle[]
{
new Rectangle(86, 6, 270, 364),
};
// Suggestion #2.
// Analyze the image visually and set the points that belong to separated objects.
args.ObjectsPoints = new Point[][]
{
new Point[] { new Point(103, 326) },
new Point[] { new Point(280, 43) },
new Point[] { new Point(319, 86) },
};
// Each cluster (segment) will be stored to a separate PNG file.
Aspose.Imaging.ImageOptions.PngOptions exportOptions = new Aspose.Imaging.ImageOptions.PngOptions();
exportOptions.ColorType = Aspose.Imaging.FileFormats.Png.PngColorType.TruecolorWithAlpha;
exportOptions.Source = new Aspose.Imaging.Sources.StreamSource(new System.IO.MemoryStream());
Aspose.Imaging.Masking.Options.MaskingOptions maskingOptions = new Aspose.Imaging.Masking.Options.MaskingOptions();
// Use GraphCut clustering.
maskingOptions.Method = Masking.Options.SegmentationMethod.GraphCut;
maskingOptions.Decompose = false;
maskingOptions.Args = args;
// The backgroung color will be orange.
maskingOptions.BackgroundReplacementColor = Aspose.Imaging.Color.Orange;
maskingOptions.ExportOptions = exportOptions;
// Create an instance of the ImageMasking class.
Aspose.Imaging.Masking.ImageMasking masking = new Aspose.Imaging.Masking.ImageMasking(image);
// Divide the source image into several clusters (segments).
using (Aspose.Imaging.Masking.Result.MaskingResult maskingResult = masking.Decompose(maskingOptions))
{
// Obtain images from masking result and save them to PNG.
for (int i = 0; i < maskingResult.Length; i++)
{
string outputFileName = string.Format("Gorilla.Segment{0}.png", maskingResult[i].ObjectNumber);
using (Aspose.Imaging.Image resultImage = maskingResult[i].GetImage())
{
resultImage.Save(dir + outputFileName);
}
}
}
}Saving the masking session to a file for long sessions, as well as for the possibility of resuming the session in another environment.```csharp [C#]
string dir = "c:\\temp\\";
string sessionBackupFile = dir + "session.bak";
// Masking export options
Aspose.Imaging.ImageOptions.PngOptions exportOptions = new Aspose.Imaging.ImageOptions.PngOptions();
exportOptions.ColorType = Aspose.Imaging.FileFormats.Png.PngColorType.TruecolorWithAlpha;
exportOptions.Source = new Aspose.Imaging.Sources.StreamSource(new System.IO.MemoryStream());
Aspose.Imaging.Masking.Options.MaskingOptions maskingOptions = new Aspose.Imaging.Masking.Options.MaskingOptions();
// Use GraphCut clustering.
maskingOptions.Method = Masking.Options.SegmentationMethod.GraphCut;
maskingOptions.Decompose = false;
maskingOptions.Args = new Aspose.Imaging.Masking.Options.AutoMaskingArgs();
// The backgroung color will be orange.
maskingOptions.BackgroundReplacementColor = Aspose.Imaging.Color.Orange;
maskingOptions.ExportOptions = exportOptions;
// Starting a session for the first time and saving to a file
using (Aspose.Imaging.RasterImage image = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "Gorilla.bmp"))
{
// Create an instance of the ImageMasking class.
Aspose.Imaging.Masking.ImageMasking masking = new Aspose.Imaging.Masking.ImageMasking(image);
using (Aspose.Imaging.Masking.IMaskingSession session = masking.CreateSession(maskingOptions))
{
using (Aspose.Imaging.Masking.Result.MaskingResult maskingResult = session.Decompose())
{
using (Aspose.Imaging.RasterImage segmentImage = maskingResult[1].GetImage())
{
segmentImage.Save(dir + "step1.png");
}
}
session.Save(sessionBackupFile);
}
}
// Resuming a masking session from a file
using (Aspose.Imaging.RasterImage image = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "Gorilla.bmp"))
{
// Create an instance of the ImageMasking class.
Aspose.Imaging.Masking.ImageMasking masking = new Aspose.Imaging.Masking.ImageMasking(image);
using (Aspose.Imaging.Masking.IMaskingSession session = masking.LoadSession(sessionBackupFile))
{
Aspose.Imaging.Masking.Options.AutoMaskingArgs args = new Aspose.Imaging.Masking.Options.AutoMaskingArgs();
// Analyze the image visually and set the points that belong to separated objects.
args.ObjectsPoints = new Point[][]
{
new Point[]
{
new Point(0, 0), new Point(0, 1), new Point(1, 0),
new Point(1, 1), new Point(2, 0), new Point(2, 1),
new Point(3, 0), new Point(3, 1)
},
};
using (Aspose.Imaging.Masking.Result.MaskingResult maskingResult = session.ImproveDecomposition(args))
{
// Explicit transfer of export options, since it is not serializable
maskingResult.MaskingOptions.ExportOptions = exportOptions;
using (Aspose.Imaging.RasterImage segmentImage = maskingResult[1].GetImage())
{
segmentImage.Save(dir + "step2.png");
}
}
}
}
### <a id="Aspose_Imaging_Masking_Options_MaskingOptions_Decompose"></a> Decompose
Gets or sets a value indicating whether
needless to separate each Shape from mask as individual object or as united object from mask separated from background.
```csharp
public bool Decompose { get; set; }Property Value
Examples
This example shows how to decompose a raster image into multiple images using image masking and a manual mask. Image masking is an image processing technique that is used to split the background from the foreground image objects.```csharp [C#]
string dir = "c:\\temp\\";
// Define a manual mask.
Aspose.Imaging.GraphicsPath manualMask = new Aspose.Imaging.GraphicsPath();
Aspose.Imaging.Figure figure = new Aspose.Imaging.Figure();
figure.AddShape(new Aspose.Imaging.Shapes.EllipseShape(new RectangleF(50, 50, 40, 40)));
figure.AddShape(new Aspose.Imaging.Shapes.RectangleShape(new RectangleF(10, 20, 50, 30)));
manualMask.AddFigure(figure);
// Each cluster (segment) will be stored to a separate PNG file.
Aspose.Imaging.ImageOptions.PngOptions exportOptions = new Aspose.Imaging.ImageOptions.PngOptions();
exportOptions.ColorType = Aspose.Imaging.FileFormats.Png.PngColorType.TruecolorWithAlpha;
exportOptions.Source = new Aspose.Imaging.Sources.StreamSource(new System.IO.MemoryStream());
// Set the manual mask.
Aspose.Imaging.Masking.Options.ManualMaskingArgs args = new Aspose.Imaging.Masking.Options.ManualMaskingArgs();
args.Mask = manualMask;
using (RasterImage image = (RasterImage)Image.Load(dir + "Blue hills.png"))
{
Aspose.Imaging.Masking.Options.MaskingOptions maskingOptions = new Aspose.Imaging.Masking.Options.MaskingOptions();
// Use manual clustering algorithm.
maskingOptions.Method = Masking.Options.SegmentationMethod.Manual;
// All shapes making up a mask will be combined into one.
maskingOptions.Decompose = false;
maskingOptions.Args = args;
// The backgroung color will be orange.
maskingOptions.BackgroundReplacementColor = Aspose.Imaging.Color.Orange;
maskingOptions.ExportOptions = exportOptions;
// The area of the source image that masking will be applied to.
maskingOptions.MaskingArea = new Rectangle(50, 50, 120, 120);
// Create an instance of the ImageMasking class.
Aspose.Imaging.Masking.ImageMasking masking = new Aspose.Imaging.Masking.ImageMasking(image);
// Divide the source image into several clusters (segments).
using (Aspose.Imaging.Masking.Result.MaskingResult maskingResult = masking.Decompose(maskingOptions))
{
// Obtain images from masking result and save them to PNG.
for (int i = 0; i < maskingResult.Length; i++)
{
string outputFileName = string.Format("Blue hills.Segment{0}.png", maskingResult[i].ObjectNumber);
using (Aspose.Imaging.Image resultImage = maskingResult[i].GetImage())
{
resultImage.Save(dir + outputFileName);
}
}
}
}
### <a id="Aspose_Imaging_Masking_Options_MaskingOptions_ExportOptions"></a> ExportOptions
Gets or sets the image export options.
```csharp
public ImageOptionsBase ExportOptions { get; set; }Property Value
Examples
This example shows how to decompose a raster image into multiple images using image masking and the K-means segmentation algorithm. Image masking is an image processing technique that is used to split the background from the foreground image objects.```csharp [C#]
string dir = "c:\\temp\\";
using (Aspose.Imaging.RasterImage image = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "Blue hills.png"))
{
Aspose.Imaging.Masking.Options.AutoMaskingArgs args = new Aspose.Imaging.Masking.Options.AutoMaskingArgs();
// Set the number of clusters (separated objects). The default value is 2, the foreground object and the background.
args.NumberOfObjects = 3;
// Set the maximum number of iterations.
args.MaxIterationNumber = 50;
// Set the precision of segmentation method (optional)
args.Precision = 1;
// Each cluster (segment) will be stored to a separate PNG file.
Aspose.Imaging.ImageOptions.PngOptions exportOptions = new Aspose.Imaging.ImageOptions.PngOptions();
exportOptions.ColorType = Aspose.Imaging.FileFormats.Png.PngColorType.TruecolorWithAlpha;
exportOptions.Source = new Aspose.Imaging.Sources.StreamSource(new System.IO.MemoryStream());
Aspose.Imaging.Masking.Options.MaskingOptions maskingOptions = new Aspose.Imaging.Masking.Options.MaskingOptions();
// Use K-means clustering.
// K-means clustering allows to split image into several independent clusters (segments).
maskingOptions.Method = Masking.Options.SegmentationMethod.KMeans;
maskingOptions.Decompose = true;
maskingOptions.Args = args;
// The backgroung color will be orange.
maskingOptions.BackgroundReplacementColor = Aspose.Imaging.Color.Orange;
maskingOptions.ExportOptions = exportOptions;
// Create an instance of the ImageMasking class.
Aspose.Imaging.Masking.ImageMasking masking = new Aspose.Imaging.Masking.ImageMasking(image);
// Divide the source image into several clusters (segments).
using (Aspose.Imaging.Masking.Result.MaskingResult maskingResult = masking.Decompose(maskingOptions))
{
// Obtain images from masking result and save them to PNG.
for (int i = 0; i < maskingResult.Length; i++)
{
string outputFileName = string.Format("Blue hills.Segment{0}.png", maskingResult[i].ObjectNumber);
using (Aspose.Imaging.Image resultImage = maskingResult[i].GetImage())
{
resultImage.Save(dir + outputFileName);
}
}
}
}
Using a segment mask to speed up the segmentation process```csharp
[C#]
// Masking export options
Aspose.Imaging.ImageOptions.PngOptions exportOptions = new Aspose.Imaging.ImageOptions.PngOptions();
exportOptions.ColorType = Aspose.Imaging.FileFormats.Png.PngColorType.TruecolorWithAlpha;
exportOptions.Source = new Aspose.Imaging.Sources.StreamSource(new System.IO.MemoryStream());
Aspose.Imaging.Masking.Options.MaskingOptions maskingOptions = new Aspose.Imaging.Masking.Options.MaskingOptions();
// Use GraphCut clustering.
maskingOptions.Method = Masking.Options.SegmentationMethod.GraphCut;
maskingOptions.Decompose = false;
maskingOptions.Args = new Aspose.Imaging.Masking.Options.AutoMaskingArgs();
// The backgroung color will be transparent.
maskingOptions.BackgroundReplacementColor = Aspose.Imaging.Color.Transparent;
maskingOptions.ExportOptions = exportOptions;
string dir = "c:\\temp\\";
using (Aspose.Imaging.RasterImage image = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "BigImage.jpg"))
{
Aspose.Imaging.Size imageSize = image.Size;
// Reducing image size to speed up the segmentation process
image.ResizeHeightProportionally(600, Aspose.Imaging.ResizeType.HighQualityResample);
// Create an instance of the ImageMasking class.
Aspose.Imaging.Masking.ImageMasking masking = new Aspose.Imaging.Masking.ImageMasking(image);
// Divide the source image into several clusters (segments).
using (Aspose.Imaging.Masking.Result.MaskingResult maskingResult = masking.Decompose(maskingOptions))
{
// Getting the foreground mask
using (Aspose.Imaging.RasterImage foregroundMask = maskingResult[1].GetMask())
{
// Increase the size of the mask to the size of the original image
foregroundMask.Resize(imageSize.Width, imageSize.Height, Aspose.Imaging.ResizeType.NearestNeighbourResample);
// Applying the mask to the original image to obtain a foreground segment
using (Aspose.Imaging.RasterImage originImage = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "BigImage.jpg"))
{
Aspose.Imaging.Masking.ImageMasking.ApplyMask(originImage, foregroundMask, maskingOptions);
originImage.Save(dir + "BigImage_foreground.png", exportOptions);
}
}
}
}This example shows how to decompose a raster image into multiple images using image masking and a manual mask. Image masking is an image processing technique that is used to split the background from the foreground image objects.```csharp [C#]
string dir = "c:\\temp\\";
// Define a manual mask.
Aspose.Imaging.GraphicsPath manualMask = new Aspose.Imaging.GraphicsPath();
Aspose.Imaging.Figure figure = new Aspose.Imaging.Figure();
figure.AddShape(new Aspose.Imaging.Shapes.EllipseShape(new RectangleF(50, 50, 40, 40)));
figure.AddShape(new Aspose.Imaging.Shapes.RectangleShape(new RectangleF(10, 20, 50, 30)));
manualMask.AddFigure(figure);
// Each cluster (segment) will be stored to a separate PNG file.
Aspose.Imaging.ImageOptions.PngOptions exportOptions = new Aspose.Imaging.ImageOptions.PngOptions();
exportOptions.ColorType = Aspose.Imaging.FileFormats.Png.PngColorType.TruecolorWithAlpha;
exportOptions.Source = new Aspose.Imaging.Sources.StreamSource(new System.IO.MemoryStream());
// Set the manual mask.
Aspose.Imaging.Masking.Options.ManualMaskingArgs args = new Aspose.Imaging.Masking.Options.ManualMaskingArgs();
args.Mask = manualMask;
using (RasterImage image = (RasterImage)Image.Load(dir + "Blue hills.png"))
{
Aspose.Imaging.Masking.Options.MaskingOptions maskingOptions = new Aspose.Imaging.Masking.Options.MaskingOptions();
// Use manual clustering algorithm.
maskingOptions.Method = Masking.Options.SegmentationMethod.Manual;
// All shapes making up a mask will be combined into one.
maskingOptions.Decompose = false;
maskingOptions.Args = args;
// The backgroung color will be orange.
maskingOptions.BackgroundReplacementColor = Aspose.Imaging.Color.Orange;
maskingOptions.ExportOptions = exportOptions;
// The area of the source image that masking will be applied to.
maskingOptions.MaskingArea = new Rectangle(50, 50, 120, 120);
// Create an instance of the ImageMasking class.
Aspose.Imaging.Masking.ImageMasking masking = new Aspose.Imaging.Masking.ImageMasking(image);
// Divide the source image into several clusters (segments).
using (Aspose.Imaging.Masking.Result.MaskingResult maskingResult = masking.Decompose(maskingOptions))
{
// Obtain images from masking result and save them to PNG.
for (int i = 0; i < maskingResult.Length; i++)
{
string outputFileName = string.Format("Blue hills.Segment{0}.png", maskingResult[i].ObjectNumber);
using (Aspose.Imaging.Image resultImage = maskingResult[i].GetImage())
{
resultImage.Save(dir + outputFileName);
}
}
}
}
This example shows how to specify suggestions for image masking algorithm to improve precision of segmentation (clustering) method. Image masking is an image processing technique that is used to split the background from the foreground image objects.```csharp
[C#]
string dir = "c:\\temp\\";
using (Aspose.Imaging.RasterImage image = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "Gorilla.bmp"))
{
Aspose.Imaging.Masking.Options.AutoMaskingArgs args = new Aspose.Imaging.Masking.Options.AutoMaskingArgs();
// Suggestion #1.
// Analyze the image visually and set the area of interest. The result of segmentation will include only objects that will be completely located within this area.
args.ObjectsRectangles = new Rectangle[]
{
new Rectangle(86, 6, 270, 364),
};
// Suggestion #2.
// Analyze the image visually and set the points that belong to separated objects.
args.ObjectsPoints = new Point[][]
{
new Point[] { new Point(103, 326) },
new Point[] { new Point(280, 43) },
new Point[] { new Point(319, 86) },
};
// Each cluster (segment) will be stored to a separate PNG file.
Aspose.Imaging.ImageOptions.PngOptions exportOptions = new Aspose.Imaging.ImageOptions.PngOptions();
exportOptions.ColorType = Aspose.Imaging.FileFormats.Png.PngColorType.TruecolorWithAlpha;
exportOptions.Source = new Aspose.Imaging.Sources.StreamSource(new System.IO.MemoryStream());
Aspose.Imaging.Masking.Options.MaskingOptions maskingOptions = new Aspose.Imaging.Masking.Options.MaskingOptions();
// Use GraphCut clustering.
maskingOptions.Method = Masking.Options.SegmentationMethod.GraphCut;
maskingOptions.Decompose = false;
maskingOptions.Args = args;
// The backgroung color will be orange.
maskingOptions.BackgroundReplacementColor = Aspose.Imaging.Color.Orange;
maskingOptions.ExportOptions = exportOptions;
// Create an instance of the ImageMasking class.
Aspose.Imaging.Masking.ImageMasking masking = new Aspose.Imaging.Masking.ImageMasking(image);
// Divide the source image into several clusters (segments).
using (Aspose.Imaging.Masking.Result.MaskingResult maskingResult = masking.Decompose(maskingOptions))
{
// Obtain images from masking result and save them to PNG.
for (int i = 0; i < maskingResult.Length; i++)
{
string outputFileName = string.Format("Gorilla.Segment{0}.png", maskingResult[i].ObjectNumber);
using (Aspose.Imaging.Image resultImage = maskingResult[i].GetImage())
{
resultImage.Save(dir + outputFileName);
}
}
}
}Saving the masking session to a file for long sessions, as well as for the possibility of resuming the session in another environment.```csharp [C#]
string dir = "c:\\temp\\";
string sessionBackupFile = dir + "session.bak";
// Masking export options
Aspose.Imaging.ImageOptions.PngOptions exportOptions = new Aspose.Imaging.ImageOptions.PngOptions();
exportOptions.ColorType = Aspose.Imaging.FileFormats.Png.PngColorType.TruecolorWithAlpha;
exportOptions.Source = new Aspose.Imaging.Sources.StreamSource(new System.IO.MemoryStream());
Aspose.Imaging.Masking.Options.MaskingOptions maskingOptions = new Aspose.Imaging.Masking.Options.MaskingOptions();
// Use GraphCut clustering.
maskingOptions.Method = Masking.Options.SegmentationMethod.GraphCut;
maskingOptions.Decompose = false;
maskingOptions.Args = new Aspose.Imaging.Masking.Options.AutoMaskingArgs();
// The backgroung color will be orange.
maskingOptions.BackgroundReplacementColor = Aspose.Imaging.Color.Orange;
maskingOptions.ExportOptions = exportOptions;
// Starting a session for the first time and saving to a file
using (Aspose.Imaging.RasterImage image = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "Gorilla.bmp"))
{
// Create an instance of the ImageMasking class.
Aspose.Imaging.Masking.ImageMasking masking = new Aspose.Imaging.Masking.ImageMasking(image);
using (Aspose.Imaging.Masking.IMaskingSession session = masking.CreateSession(maskingOptions))
{
using (Aspose.Imaging.Masking.Result.MaskingResult maskingResult = session.Decompose())
{
using (Aspose.Imaging.RasterImage segmentImage = maskingResult[1].GetImage())
{
segmentImage.Save(dir + "step1.png");
}
}
session.Save(sessionBackupFile);
}
}
// Resuming a masking session from a file
using (Aspose.Imaging.RasterImage image = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "Gorilla.bmp"))
{
// Create an instance of the ImageMasking class.
Aspose.Imaging.Masking.ImageMasking masking = new Aspose.Imaging.Masking.ImageMasking(image);
using (Aspose.Imaging.Masking.IMaskingSession session = masking.LoadSession(sessionBackupFile))
{
Aspose.Imaging.Masking.Options.AutoMaskingArgs args = new Aspose.Imaging.Masking.Options.AutoMaskingArgs();
// Analyze the image visually and set the points that belong to separated objects.
args.ObjectsPoints = new Point[][]
{
new Point[]
{
new Point(0, 0), new Point(0, 1), new Point(1, 0),
new Point(1, 1), new Point(2, 0), new Point(2, 1),
new Point(3, 0), new Point(3, 1)
},
};
using (Aspose.Imaging.Masking.Result.MaskingResult maskingResult = session.ImproveDecomposition(args))
{
// Explicit transfer of export options, since it is not serializable
maskingResult.MaskingOptions.ExportOptions = exportOptions;
using (Aspose.Imaging.RasterImage segmentImage = maskingResult[1].GetImage())
{
segmentImage.Save(dir + "step2.png");
}
}
}
}
### <a id="Aspose_Imaging_Masking_Options_MaskingOptions_MaskingArea"></a> MaskingArea
Gets or sets the masking area.
```csharp
public Rectangle MaskingArea { get; set; }Property Value
Examples
This example shows how to decompose a raster image into multiple images using image masking and a manual mask. Image masking is an image processing technique that is used to split the background from the foreground image objects.```csharp [C#]
string dir = "c:\\temp\\";
// Define a manual mask.
Aspose.Imaging.GraphicsPath manualMask = new Aspose.Imaging.GraphicsPath();
Aspose.Imaging.Figure figure = new Aspose.Imaging.Figure();
figure.AddShape(new Aspose.Imaging.Shapes.EllipseShape(new RectangleF(50, 50, 40, 40)));
figure.AddShape(new Aspose.Imaging.Shapes.RectangleShape(new RectangleF(10, 20, 50, 30)));
manualMask.AddFigure(figure);
// Each cluster (segment) will be stored to a separate PNG file.
Aspose.Imaging.ImageOptions.PngOptions exportOptions = new Aspose.Imaging.ImageOptions.PngOptions();
exportOptions.ColorType = Aspose.Imaging.FileFormats.Png.PngColorType.TruecolorWithAlpha;
exportOptions.Source = new Aspose.Imaging.Sources.StreamSource(new System.IO.MemoryStream());
// Set the manual mask.
Aspose.Imaging.Masking.Options.ManualMaskingArgs args = new Aspose.Imaging.Masking.Options.ManualMaskingArgs();
args.Mask = manualMask;
using (RasterImage image = (RasterImage)Image.Load(dir + "Blue hills.png"))
{
Aspose.Imaging.Masking.Options.MaskingOptions maskingOptions = new Aspose.Imaging.Masking.Options.MaskingOptions();
// Use manual clustering algorithm.
maskingOptions.Method = Masking.Options.SegmentationMethod.Manual;
// All shapes making up a mask will be combined into one.
maskingOptions.Decompose = false;
maskingOptions.Args = args;
// The backgroung color will be orange.
maskingOptions.BackgroundReplacementColor = Aspose.Imaging.Color.Orange;
maskingOptions.ExportOptions = exportOptions;
// The area of the source image that masking will be applied to.
maskingOptions.MaskingArea = new Rectangle(50, 50, 120, 120);
// Create an instance of the ImageMasking class.
Aspose.Imaging.Masking.ImageMasking masking = new Aspose.Imaging.Masking.ImageMasking(image);
// Divide the source image into several clusters (segments).
using (Aspose.Imaging.Masking.Result.MaskingResult maskingResult = masking.Decompose(maskingOptions))
{
// Obtain images from masking result and save them to PNG.
for (int i = 0; i < maskingResult.Length; i++)
{
string outputFileName = string.Format("Blue hills.Segment{0}.png", maskingResult[i].ObjectNumber);
using (Aspose.Imaging.Image resultImage = maskingResult[i].GetImage())
{
resultImage.Save(dir + outputFileName);
}
}
}
}
### <a id="Aspose_Imaging_Masking_Options_MaskingOptions_Method"></a> Method
Gets or sets the segmentation method.
```csharp
public SegmentationMethod Method { get; set; }Property Value
Examples
This example shows how to decompose a raster image into multiple images using image masking and the K-means segmentation algorithm. Image masking is an image processing technique that is used to split the background from the foreground image objects.```csharp [C#]
string dir = "c:\\temp\\";
using (Aspose.Imaging.RasterImage image = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "Blue hills.png"))
{
Aspose.Imaging.Masking.Options.AutoMaskingArgs args = new Aspose.Imaging.Masking.Options.AutoMaskingArgs();
// Set the number of clusters (separated objects). The default value is 2, the foreground object and the background.
args.NumberOfObjects = 3;
// Set the maximum number of iterations.
args.MaxIterationNumber = 50;
// Set the precision of segmentation method (optional)
args.Precision = 1;
// Each cluster (segment) will be stored to a separate PNG file.
Aspose.Imaging.ImageOptions.PngOptions exportOptions = new Aspose.Imaging.ImageOptions.PngOptions();
exportOptions.ColorType = Aspose.Imaging.FileFormats.Png.PngColorType.TruecolorWithAlpha;
exportOptions.Source = new Aspose.Imaging.Sources.StreamSource(new System.IO.MemoryStream());
Aspose.Imaging.Masking.Options.MaskingOptions maskingOptions = new Aspose.Imaging.Masking.Options.MaskingOptions();
// Use K-means clustering.
// K-means clustering allows to split image into several independent clusters (segments).
maskingOptions.Method = Masking.Options.SegmentationMethod.KMeans;
maskingOptions.Decompose = true;
maskingOptions.Args = args;
// The backgroung color will be orange.
maskingOptions.BackgroundReplacementColor = Aspose.Imaging.Color.Orange;
maskingOptions.ExportOptions = exportOptions;
// Create an instance of the ImageMasking class.
Aspose.Imaging.Masking.ImageMasking masking = new Aspose.Imaging.Masking.ImageMasking(image);
// Divide the source image into several clusters (segments).
using (Aspose.Imaging.Masking.Result.MaskingResult maskingResult = masking.Decompose(maskingOptions))
{
// Obtain images from masking result and save them to PNG.
for (int i = 0; i < maskingResult.Length; i++)
{
string outputFileName = string.Format("Blue hills.Segment{0}.png", maskingResult[i].ObjectNumber);
using (Aspose.Imaging.Image resultImage = maskingResult[i].GetImage())
{
resultImage.Save(dir + outputFileName);
}
}
}
}
Using a segment mask to speed up the segmentation process```csharp
[C#]
// Masking export options
Aspose.Imaging.ImageOptions.PngOptions exportOptions = new Aspose.Imaging.ImageOptions.PngOptions();
exportOptions.ColorType = Aspose.Imaging.FileFormats.Png.PngColorType.TruecolorWithAlpha;
exportOptions.Source = new Aspose.Imaging.Sources.StreamSource(new System.IO.MemoryStream());
Aspose.Imaging.Masking.Options.MaskingOptions maskingOptions = new Aspose.Imaging.Masking.Options.MaskingOptions();
// Use GraphCut clustering.
maskingOptions.Method = Masking.Options.SegmentationMethod.GraphCut;
maskingOptions.Decompose = false;
maskingOptions.Args = new Aspose.Imaging.Masking.Options.AutoMaskingArgs();
// The backgroung color will be transparent.
maskingOptions.BackgroundReplacementColor = Aspose.Imaging.Color.Transparent;
maskingOptions.ExportOptions = exportOptions;
string dir = "c:\\temp\\";
using (Aspose.Imaging.RasterImage image = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "BigImage.jpg"))
{
Aspose.Imaging.Size imageSize = image.Size;
// Reducing image size to speed up the segmentation process
image.ResizeHeightProportionally(600, Aspose.Imaging.ResizeType.HighQualityResample);
// Create an instance of the ImageMasking class.
Aspose.Imaging.Masking.ImageMasking masking = new Aspose.Imaging.Masking.ImageMasking(image);
// Divide the source image into several clusters (segments).
using (Aspose.Imaging.Masking.Result.MaskingResult maskingResult = masking.Decompose(maskingOptions))
{
// Getting the foreground mask
using (Aspose.Imaging.RasterImage foregroundMask = maskingResult[1].GetMask())
{
// Increase the size of the mask to the size of the original image
foregroundMask.Resize(imageSize.Width, imageSize.Height, Aspose.Imaging.ResizeType.NearestNeighbourResample);
// Applying the mask to the original image to obtain a foreground segment
using (Aspose.Imaging.RasterImage originImage = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "BigImage.jpg"))
{
Aspose.Imaging.Masking.ImageMasking.ApplyMask(originImage, foregroundMask, maskingOptions);
originImage.Save(dir + "BigImage_foreground.png", exportOptions);
}
}
}
}This example shows how to decompose a raster image into multiple images using image masking and a manual mask. Image masking is an image processing technique that is used to split the background from the foreground image objects.```csharp [C#]
string dir = "c:\\temp\\";
// Define a manual mask.
Aspose.Imaging.GraphicsPath manualMask = new Aspose.Imaging.GraphicsPath();
Aspose.Imaging.Figure figure = new Aspose.Imaging.Figure();
figure.AddShape(new Aspose.Imaging.Shapes.EllipseShape(new RectangleF(50, 50, 40, 40)));
figure.AddShape(new Aspose.Imaging.Shapes.RectangleShape(new RectangleF(10, 20, 50, 30)));
manualMask.AddFigure(figure);
// Each cluster (segment) will be stored to a separate PNG file.
Aspose.Imaging.ImageOptions.PngOptions exportOptions = new Aspose.Imaging.ImageOptions.PngOptions();
exportOptions.ColorType = Aspose.Imaging.FileFormats.Png.PngColorType.TruecolorWithAlpha;
exportOptions.Source = new Aspose.Imaging.Sources.StreamSource(new System.IO.MemoryStream());
// Set the manual mask.
Aspose.Imaging.Masking.Options.ManualMaskingArgs args = new Aspose.Imaging.Masking.Options.ManualMaskingArgs();
args.Mask = manualMask;
using (RasterImage image = (RasterImage)Image.Load(dir + "Blue hills.png"))
{
Aspose.Imaging.Masking.Options.MaskingOptions maskingOptions = new Aspose.Imaging.Masking.Options.MaskingOptions();
// Use manual clustering algorithm.
maskingOptions.Method = Masking.Options.SegmentationMethod.Manual;
// All shapes making up a mask will be combined into one.
maskingOptions.Decompose = false;
maskingOptions.Args = args;
// The backgroung color will be orange.
maskingOptions.BackgroundReplacementColor = Aspose.Imaging.Color.Orange;
maskingOptions.ExportOptions = exportOptions;
// The area of the source image that masking will be applied to.
maskingOptions.MaskingArea = new Rectangle(50, 50, 120, 120);
// Create an instance of the ImageMasking class.
Aspose.Imaging.Masking.ImageMasking masking = new Aspose.Imaging.Masking.ImageMasking(image);
// Divide the source image into several clusters (segments).
using (Aspose.Imaging.Masking.Result.MaskingResult maskingResult = masking.Decompose(maskingOptions))
{
// Obtain images from masking result and save them to PNG.
for (int i = 0; i < maskingResult.Length; i++)
{
string outputFileName = string.Format("Blue hills.Segment{0}.png", maskingResult[i].ObjectNumber);
using (Aspose.Imaging.Image resultImage = maskingResult[i].GetImage())
{
resultImage.Save(dir + outputFileName);
}
}
}
}
This example shows how to specify suggestions for image masking algorithm to improve precision of segmentation (clustering) method. Image masking is an image processing technique that is used to split the background from the foreground image objects.```csharp
[C#]
string dir = "c:\\temp\\";
using (Aspose.Imaging.RasterImage image = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "Gorilla.bmp"))
{
Aspose.Imaging.Masking.Options.AutoMaskingArgs args = new Aspose.Imaging.Masking.Options.AutoMaskingArgs();
// Suggestion #1.
// Analyze the image visually and set the area of interest. The result of segmentation will include only objects that will be completely located within this area.
args.ObjectsRectangles = new Rectangle[]
{
new Rectangle(86, 6, 270, 364),
};
// Suggestion #2.
// Analyze the image visually and set the points that belong to separated objects.
args.ObjectsPoints = new Point[][]
{
new Point[] { new Point(103, 326) },
new Point[] { new Point(280, 43) },
new Point[] { new Point(319, 86) },
};
// Each cluster (segment) will be stored to a separate PNG file.
Aspose.Imaging.ImageOptions.PngOptions exportOptions = new Aspose.Imaging.ImageOptions.PngOptions();
exportOptions.ColorType = Aspose.Imaging.FileFormats.Png.PngColorType.TruecolorWithAlpha;
exportOptions.Source = new Aspose.Imaging.Sources.StreamSource(new System.IO.MemoryStream());
Aspose.Imaging.Masking.Options.MaskingOptions maskingOptions = new Aspose.Imaging.Masking.Options.MaskingOptions();
// Use GraphCut clustering.
maskingOptions.Method = Masking.Options.SegmentationMethod.GraphCut;
maskingOptions.Decompose = false;
maskingOptions.Args = args;
// The backgroung color will be orange.
maskingOptions.BackgroundReplacementColor = Aspose.Imaging.Color.Orange;
maskingOptions.ExportOptions = exportOptions;
// Create an instance of the ImageMasking class.
Aspose.Imaging.Masking.ImageMasking masking = new Aspose.Imaging.Masking.ImageMasking(image);
// Divide the source image into several clusters (segments).
using (Aspose.Imaging.Masking.Result.MaskingResult maskingResult = masking.Decompose(maskingOptions))
{
// Obtain images from masking result and save them to PNG.
for (int i = 0; i < maskingResult.Length; i++)
{
string outputFileName = string.Format("Gorilla.Segment{0}.png", maskingResult[i].ObjectNumber);
using (Aspose.Imaging.Image resultImage = maskingResult[i].GetImage())
{
resultImage.Save(dir + outputFileName);
}
}
}
}Saving the masking session to a file for long sessions, as well as for the possibility of resuming the session in another environment.```csharp [C#]
string dir = "c:\\temp\\";
string sessionBackupFile = dir + "session.bak";
// Masking export options
Aspose.Imaging.ImageOptions.PngOptions exportOptions = new Aspose.Imaging.ImageOptions.PngOptions();
exportOptions.ColorType = Aspose.Imaging.FileFormats.Png.PngColorType.TruecolorWithAlpha;
exportOptions.Source = new Aspose.Imaging.Sources.StreamSource(new System.IO.MemoryStream());
Aspose.Imaging.Masking.Options.MaskingOptions maskingOptions = new Aspose.Imaging.Masking.Options.MaskingOptions();
// Use GraphCut clustering.
maskingOptions.Method = Masking.Options.SegmentationMethod.GraphCut;
maskingOptions.Decompose = false;
maskingOptions.Args = new Aspose.Imaging.Masking.Options.AutoMaskingArgs();
// The backgroung color will be orange.
maskingOptions.BackgroundReplacementColor = Aspose.Imaging.Color.Orange;
maskingOptions.ExportOptions = exportOptions;
// Starting a session for the first time and saving to a file
using (Aspose.Imaging.RasterImage image = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "Gorilla.bmp"))
{
// Create an instance of the ImageMasking class.
Aspose.Imaging.Masking.ImageMasking masking = new Aspose.Imaging.Masking.ImageMasking(image);
using (Aspose.Imaging.Masking.IMaskingSession session = masking.CreateSession(maskingOptions))
{
using (Aspose.Imaging.Masking.Result.MaskingResult maskingResult = session.Decompose())
{
using (Aspose.Imaging.RasterImage segmentImage = maskingResult[1].GetImage())
{
segmentImage.Save(dir + "step1.png");
}
}
session.Save(sessionBackupFile);
}
}
// Resuming a masking session from a file
using (Aspose.Imaging.RasterImage image = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "Gorilla.bmp"))
{
// Create an instance of the ImageMasking class.
Aspose.Imaging.Masking.ImageMasking masking = new Aspose.Imaging.Masking.ImageMasking(image);
using (Aspose.Imaging.Masking.IMaskingSession session = masking.LoadSession(sessionBackupFile))
{
Aspose.Imaging.Masking.Options.AutoMaskingArgs args = new Aspose.Imaging.Masking.Options.AutoMaskingArgs();
// Analyze the image visually and set the points that belong to separated objects.
args.ObjectsPoints = new Point[][]
{
new Point[]
{
new Point(0, 0), new Point(0, 1), new Point(1, 0),
new Point(1, 1), new Point(2, 0), new Point(2, 1),
new Point(3, 0), new Point(3, 1)
},
};
using (Aspose.Imaging.Masking.Result.MaskingResult maskingResult = session.ImproveDecomposition(args))
{
// Explicit transfer of export options, since it is not serializable
maskingResult.MaskingOptions.ExportOptions = exportOptions;
using (Aspose.Imaging.RasterImage segmentImage = maskingResult[1].GetImage())
{
segmentImage.Save(dir + "step2.png");
}
}
}
}