Class ImageMasking

Namespace: Aspose.Imaging.Masking
Assembly: Aspose.Imaging.dll (25.7.0)

Provides image masking operations

public class ImageMasking
   {
       private Image _image;
       private Shape _shape;
       public void ApplyMask(Image image, Shape shape)
       {
           _image = image;
           _shape = shape;
       }
   }

Inheritance

object ← ImageMasking

Inherited Members

object.GetType() , object.MemberwiseClone() , object.ToString() , object.Equals(object?) , object.Equals(object?, object?) , object.ReferenceEquals(object?, object?) , object.GetHashCode()

Examples

Using a segment mask to speed up the segmentation process

Aspose.Imaging.ImageOptions.PngOptions exportOptions = new Aspose.Imaging.ImageOptions.PngOptions()
   {
      ColorType = Aspose.Imaging.FileFormats.Png.PngColorType.TruecolorWithAlpha,
      Source = new Aspose.Imaging.Sources.StreamSource(new System.IO.MemoryStream()),
   };
   Aspose.Imaging.Masking.Options.MaskingOptions maskingOptions = new Aspose.Imaging.Masking.Options.MaskingOptions()
   {
      Method = Masking.Options.SegmentationMethod.GraphCut,
      Decompose = false,
      Args = new Aspose.Imaging.Masking.Options.AutoMaskingArgs(),
      BackgroundReplacementColor = Aspose.Imaging.Color.Transparent,
      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;
      image.ResizeHeightProportionally(600, Aspose.Imaging.ResizeType.HighQualityResample);
      Aspose.Imaging.Masking.ImageMasking masking = new Aspose.Imaging.Masking.ImageMasking(image);
      using (Aspose.Imaging.Masking.Result.MaskingResult maskingResult = masking.Decompose(maskingOptions))
      {
         using (Aspose.Imaging.RasterImage foregroundMask = maskingResult[1].GetMask())
         {
            foregroundMask.Resize(imageSize.Width, imageSize.Height, Aspose.Imaging.ResizeType.NearestNeighbourResample);
            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);
            }
         }
      }
   }

Saving the masking session to a file for long sessions, as well as for the possibility of resuming the session in another environment.

string dir = "c:\\temp\\";
   string sessionBackupFile = dir + "session.bak";
   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();
   maskingOptions.Method = Masking.Options.SegmentationMethod.GraphCut;
   maskingOptions.Decompose = false;
   maskingOptions.Args = new Aspose.Imaging.Masking.Options.AutoMaskingArgs();
   maskingOptions.BackgroundReplacementColor = Aspose.Imaging.Color.Orange;
   maskingOptions.ExportOptions = exportOptions;
   using (Aspose.Imaging.RasterImage image = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "Gorilla.bmp"))
   {
       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);
           }
       }
   }
   using (Aspose.Imaging.RasterImage image = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "Gorilla.bmp"))
   {
       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();
           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))
           {
               maskingResult.MaskingOptions.ExportOptions = exportOptions;
               using (Aspose.Imaging.RasterImage segmentImage = maskingResult[1].GetImage())
               {
                   segmentImage.Save(dir + "step2.png");
               }
           }
       }
   }

Constructors

ImageMasking(RasterImage)

Initializes a new instance of the Aspose.Imaging.Masking.ImageMasking class.

public ImageMasking(RasterImage sourceImage)
   {
   }

Parameters

sourceImage RasterImage

The source image.

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.

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();
       args.NumberOfObjects = 3;
       args.MaxIterationNumber = 50;
       args.Precision = 1;
       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();
       maskingOptions.Method = Masking.Options.SegmentationMethod.KMeans;
       maskingOptions.Decompose = true;
       maskingOptions.Args = args;
       maskingOptions.BackgroundReplacementColor = Aspose.Imaging.Color.Orange;
       maskingOptions.ExportOptions = exportOptions;
       Aspose.Imaging.Masking.ImageMasking masking = new Aspose.Imaging.Masking.ImageMasking(image);
       using (Aspose.Imaging.Masking.Result.MaskingResult maskingResult = masking.Decompose(maskingOptions))
       {
           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

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();
   maskingOptions.Method = Masking.Options.SegmentationMethod.GraphCut;
   maskingOptions.Decompose = false;
   maskingOptions.Args = new Aspose.Imaging.Masking.Options.AutoMaskingArgs();
   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;
       image.ResizeHeightProportionally(600, Aspose.Imaging.ResizeType.HighQualityResample);
       Aspose.Imaging.Masking.ImageMasking masking = new Aspose.Imaging.Masking.ImageMasking(image);
       using (Aspose.Imaging.Masking.Result.MaskingResult maskingResult = masking.Decompose(maskingOptions))
       {
           using (Aspose.Imaging.RasterImage foregroundMask = maskingResult[1].GetMask())
           {
               foregroundMask.Resize(imageSize.Width, imageSize.Height, Aspose.Imaging.ResizeType.NearestNeighbourResample);
               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.

string dir = "c:\\temp\\";
   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);
   Aspose.Imaging.ImageOptions.PngOptions exportOptions = new Aspose.Imaging.ImageOptions.PngOptions();
   exportOptions.ColorType = Aspose.Imaging.FileFormats.Png.PngColorType.TruecolorWithAlpha;
   exportOptions.Source = new System.IO.MemoryStream();
   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();
       maskingOptions.Method = Masking.Options.SegmentationMethod.Manual;
       maskingOptions.Decompose = false;
       maskingOptions.Args = args;
       maskingOptions.BackgroundReplacementColor = Aspose.Imaging.Color.Orange;
       maskingOptions.ExportOptions = exportOptions;
       maskingOptions.MaskingArea = new Rectangle(50, 50, 120, 120);
       Aspose.Imaging.Masking.ImageMasking masking = new Aspose.Imaging.Masking.ImageMasking(image);
       using (Aspose.Imaging.Masking.Result.MaskingResult maskingResult = masking.Decompose(maskingOptions))
       {
           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.

string dir = "c:\\temp\\";
   using (Aspose.Imaging.RasterImage image = Aspose.Imaging.Image.Load(dir + "Gorilla.bmp"))
   {
       Aspose.Imaging.Masking.Options.AutoMaskingArgs args = new Aspose.Imaging.Masking.Options.AutoMaskingArgs();
       args.ObjectsRectangles = new Rectangle[]
       {
           new Rectangle(86, 6, 270, 364),
       };
       args.ObjectsPoints = new Point[][]
       {
           new Point[] { new Point(103, 326) },
           new Point[] { new Point(280, 43) },
           new Point[] { new Point(319, 86) },
       };
       Aspose.Imaging.ImageOptions.PngOptions exportOptions = new Aspose.Imaging.ImageOptions.PngOptions();
       exportOptions.ColorType = Aspose.Imaging.FileFormats.Png.PngColorType.TruecolorWithAlpha;
       exportOptions.Source = new System.IO.MemoryStream();
       Aspose.Imaging.Masking.Options.MaskingOptions maskingOptions = new Aspose.Imaging.Masking.Options.MaskingOptions();
       maskingOptions.Method = Masking.Options.SegmentationMethod.GraphCut;
       maskingOptions.Decompose = false;
       maskingOptions.Args = args;
       maskingOptions.BackgroundReplacementColor = Aspose.Imaging.Color.Orange;
       maskingOptions.ExportOptions = exportOptions;
       Aspose.Imaging.Masking.ImageMasking masking = new Aspose.Imaging.Masking.ImageMasking(image);
       using (Aspose.Imaging.Masking.Result.MaskingResult maskingResult = masking.Decompose(maskingOptions))
       {
           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.

string dir = "c:\\temp\\";
   string sessionBackupFile = dir + "session.bak";
   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();
   maskingOptions.Method = Masking.Options.SegmentationMethod.GraphCut;
   maskingOptions.Decompose = false;
   maskingOptions.Args = new Aspose.Imaging.Masking.Options.AutoMaskingArgs();
   maskingOptions.BackgroundReplacementColor = Aspose.Imaging.Color.Orange;
   maskingOptions.ExportOptions = exportOptions;
   using (Aspose.Imaging.RasterImage image = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "Gorilla.bmp"))
   {
       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);
           }
       }
   }
   using (Aspose.Imaging.RasterImage image = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "Gorilla.bmp"))
   {
       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();
           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))
           {
               maskingResult.MaskingOptions.ExportOptions = exportOptions;
               using (Aspose.Imaging.RasterImage segmentImage = maskingResult[1].GetImage())
               {
                   segmentImage.Save(dir + "step2.png");
               }
           }
       }
   }

Exceptions

ArgumentNullException

source image is null.

Methods

ApplyMask(RasterImage, RasterImage, MaskingOptions)

Applies the mask to specified source image.

public static void ApplyMask(
       RasterImage targetImage,
       RasterImage mask,
       MaskingOptions maskingOptions)
   {
   }

Parameters

targetImage RasterImage

The target image.

mask RasterImage

The mask image to apply.

maskingOptions MaskingOptions

The masking options.

Examples

Using a segment mask to speed up the segmentation process

Aspose.Imaging.ImageOptions.PngOptions exportOptions = new Aspose.Imaging.ImageOptions.PngOptions()
   {
      ColorType = Aspose.Imaging.FileFormats.Png.PngColorType.TruecolorWithAlpha,
      Source = new Aspose.Imaging.Sources.StreamSource(new System.IO.MemoryStream()),
   };
   Aspose.Imaging.Masking.Options.MaskingOptions maskingOptions = new Aspose.Imaging.Masking.Options.MaskingOptions()
   {
      Method = Masking.Options.SegmentationMethod.GraphCut,
      Decompose = false,
      Args = new Aspose.Imaging.Masking.Options.AutoMaskingArgs(),
      BackgroundReplacementColor = Aspose.Imaging.Color.Transparent,
      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;
      image.ResizeHeightProportionally(600, Aspose.Imaging.ResizeType.HighQualityResample);
      Aspose.Imaging.Masking.ImageMasking masking = new Aspose.Imaging.Masking.ImageMasking(image);
      using (Aspose.Imaging.Masking.Result.MaskingResult maskingResult = masking.Decompose(maskingOptions))
      {
         using (Aspose.Imaging.RasterImage foregroundMask = maskingResult[1].GetMask())
         {
            foregroundMask.Resize(imageSize.Width, imageSize.Height, Aspose.Imaging.ResizeType.NearestNeighbourResample);
            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);
            }
         }
      }
   }

CreateSession(MaskingOptions)

Creates the masking session which can perform retraining decompose operations.

public IMaskingSession CreateSession(MaskingOptions options)
{
}

Parameters

options MaskingOptions

The options.

Returns

IMaskingSession

the masking session which can perform retraining decompose operations.

Examples

Saving the masking session to a file for long sessions, as well as for the possibility of resuming the session in another environment.

string dir = "c:\\temp\\";
   string sessionBackupFile = dir + "session.bak";
   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();
   maskingOptions.Method = Masking.Options.SegmentationMethod.GraphCut;
   maskingOptions.Decompose = false;
   maskingOptions.Args = new Aspose.Imaging.Masking.Options.AutoMaskingArgs();
   maskingOptions.BackgroundReplacementColor = Aspose.Imaging.Color.Orange;
   maskingOptions.ExportOptions = exportOptions;
   using (Aspose.Imaging.RasterImage image = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "Gorilla.bmp"))
   {
       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);
           }
       }
   }
   using (Aspose.Imaging.RasterImage image = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "Gorilla.bmp"))
   {
       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();
           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))
           {
               maskingResult.MaskingOptions.ExportOptions = exportOptions;
               using (Aspose.Imaging.RasterImage segmentImage = maskingResult[1].GetImage())
               {
                   segmentImage.Save(dir + "step2.png");
               }
           }
       }
   }

Decompose(MaskingOptions)

Performs the decompose operation using specified masking options

public MaskingResult Decompose(MaskingOptions options)
{
}
Here is the provided code with improved readability according to standard C# conventions:
public MaskingResult Decompose(MaskingOptions options)
{
}
This code follows the formatting guidelines of proper indentation, spacing, and general readability improvements without modifying the logic or behavior of the provided code.

Parameters

options MaskingOptions

The masking options.

Returns

MaskingResult

Result of masking operation as array of segment image providers.

Examples

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();
      args.NumberOfObjects = 3;
      args.MaxIterationNumber = 50;
      args.Precision = 1;
      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();
      maskingOptions.Method = Masking.Options.SegmentationMethod.KMeans;
      maskingOptions.Decompose = true;
      maskingOptions.Args = args;
      maskingOptions.BackgroundReplacementColor = Aspose.Imaging.Color.Orange;
      maskingOptions.ExportOptions = exportOptions;
      Aspose.Imaging.Masking.ImageMasking masking = new Aspose.Imaging.Masking.ImageMasking(image);
      using (Aspose.Imaging.Masking.Result.MaskingResult maskingResult = masking.Decompose(maskingOptions))
      {
         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

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();
   maskingOptions.Method = Masking.Options.SegmentationMethod.GraphCut;
   maskingOptions.Decompose = false;
   maskingOptions.Args = new Aspose.Imaging.Masking.Options.AutoMaskingArgs();
   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;
      image.ResizeHeightProportionally(600, Aspose.Imaging.ResizeType.HighQualityResample);
      Aspose.Imaging.Masking.ImageMasking masking = new Aspose.Imaging.Masking.ImageMasking(image);
      using (Aspose.Imaging.Masking.Result.MaskingResult maskingResult = masking.Decompose(maskingOptions))
      {
         using (Aspose.Imaging.RasterImage foregroundMask = maskingResult[1].GetMask())
         {
            foregroundMask.Resize(imageSize.Width, imageSize.Height, Aspose.Imaging.ResizeType.NearestNeighbourResample);
            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);
            }
         }
      }
   }

string dir = "c:\\temp\\";
   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);
   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.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();
       maskingOptions.Method = Masking.Options.SegmentationMethod.Manual;
       maskingOptions.Decompose = false;
       maskingOptions.Args = args;
       maskingOptions.BackgroundReplacementColor = Aspose.Imaging.Color.Orange;
       maskingOptions.ExportOptions = exportOptions;
       maskingOptions.MaskingArea = new Rectangle(50, 50, 120, 120);
       Aspose.Imaging.Masking.ImageMasking masking = new Aspose.Imaging.Masking.ImageMasking(image);
       using (Aspose.Imaging.Masking.Result.MaskingResult maskingResult = masking.Decompose(maskingOptions))
       {
           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);
               }
           }
       }
   }

string dir = "c:\\temp\\";
   using (Aspose.Imaging.RasterImage image = Aspose.Imaging.Image.Load(dir + "Gorilla.bmp"))
   {
       Aspose.Imaging.Masking.Options.AutoMaskingArgs args = new Aspose.Imaging.Masking.Options.AutoMaskingArgs();
       args.ObjectsRectangles = new Rectangle[]
       {
           new Rectangle(86, 6, 270, 364),
       };
       args.ObjectsPoints = new Point[][]
       {
           new Point[] { new Point(103, 326) },
           new Point[] { new Point(280, 43) },
           new Point[] { new Point(319, 86) },
       };
       Aspose.Imaging.ImageOptions.PngOptions exportOptions = new Aspose.Imaging.ImageOptions.PngOptions();
       exportOptions.ColorType = Aspose.Imaging.FileFormats.Png.PngColorType.TruecolorWithAlpha;
       exportOptions.Source = new System.IO.MemoryStream();
       Aspose.Imaging.Masking.Options.MaskingOptions maskingOptions = new Aspose.Imaging.Masking.Options.MaskingOptions();
       maskingOptions.Method = Masking.Options.SegmentationMethod.GraphCut;
       maskingOptions.Decompose = false;
       maskingOptions.Args = args;
       maskingOptions.BackgroundReplacementColor = Aspose.Imaging.Color.Orange;
       maskingOptions.ExportOptions = exportOptions;
       Aspose.Imaging.Masking.ImageMasking masking = new Aspose.Imaging.Masking.ImageMasking(image);
       using (Aspose.Imaging.Masking.Result.MaskingResult maskingResult = masking.Decompose(maskingOptions))
       {
           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);
               }
           }
       }
   }

DecomposeAsync(MaskingOptions)

Creates the asynchronous decompose task using specified masking options.

public IMaskingAsyncTask DecomposeAsync(MaskingOptions options)
   {
   }

Parameters

options MaskingOptions

The masking options.

Returns

IMaskingAsyncTask

The asynchronous decompose task

LoadSession(Stream)

Load the session from the specified stream.

public IMaskingSession LoadSession(Stream stream)
   {
   }
The given input code has proper indentation and spacing, but it could be improved for readability by adding blank lines between methods to separate them visually. Here's the reformatted version:
public IMaskingSession LoadSession(Stream stream)
{
}

Parameters

stream Stream

The stream.

Returns

IMaskingSession

the masking session which can perform retraining decompose operations.

LoadSession(string)

Load the session from the specified file.

public IMaskingSession LoadSession(string filePath)
{
}
I have properly indented your code and added a line break between the opening bracket and the method implementation. This follows standard C# conventions for formatting code.

Parameters

filePath string

The file path.

Returns

IMaskingSession

the masking session which can perform retraining decompose operations.

Examples

Saving the masking session to a file for long sessions, as well as for the possibility of resuming the session in another environment.

string dir = "c:\\temp\\";
   string sessionBackupFile = dir + "session.bak";
   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();
   maskingOptions.Method = Masking.Options.SegmentationMethod.GraphCut;
   maskingOptions.Decompose = false;
   maskingOptions.Args = new Aspose.Imaging.Masking.Options.AutoMaskingArgs();
   maskingOptions.BackgroundReplacementColor = Aspose.Imaging.Color.Orange;
   maskingOptions.ExportOptions = exportOptions;
   using (Aspose.Imaging.RasterImage image = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "Gorilla.bmp"))
   {
      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);
      }
   }
   using (Aspose.Imaging.RasterImage image = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "Gorilla.bmp"))
   {
      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();
         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))
         {
            maskingResult.MaskingOptions.ExportOptions = exportOptions;
            using (Aspose.Imaging.RasterImage segmentImage = maskingResult[1].GetImage())
            {
               segmentImage.Save(dir + "step2.png");
            }
         }
      }
   }