Interface IMaskingSession

Interface IMaskingSession

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

The masking session

public interface IMaskingSession : IDisposable

Implements

IDisposable

Examples

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");
                                                                                                                                                         }
                                                                                                                                                     }
                                                                                                                                                 }
                                                                                                                                             }

## Methods

### <a id="Aspose_Imaging_Masking_IMaskingSession_Decompose"></a> Decompose\(\)

Performs first rough decompose operation

```csharp
MaskingResult Decompose()

Returns

MaskingResult

Result of masking operation as array of segment image providers.

Examples

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_IMaskingSession_DecomposeAsync"></a> DecomposeAsync\(\)

Creates the asynchronous task which can perform first rough decompose operation

```csharp
IMaskingAsyncTask DecomposeAsync()

Returns

IMaskingAsyncTask

The asynchronous decompose task

ImproveDecomposition(IMaskingArgs)

Performs retraining decompose operation

MaskingResult ImproveDecomposition(IMaskingArgs maskingArguments)

Parameters

maskingArguments IMaskingArgs

The masking arguments.

Returns

MaskingResult

Result of masking operation as array of segment image providers.

Examples

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_IMaskingSession_ImproveDecompositionAsync_Aspose_Imaging_Masking_Options_IMaskingArgs_"></a> ImproveDecompositionAsync\(IMaskingArgs\)

Creates the asynchronous task which can perform retraining decompose operation

```csharp
IMaskingAsyncTask ImproveDecompositionAsync(IMaskingArgs maskingArguments)

Parameters

maskingArguments IMaskingArgs

The masking arguments.

Returns

IMaskingAsyncTask

The asynchronous decompose task

Save(Stream)

Save the session state to the specified stream.

void Save(Stream stream)

Parameters

stream Stream

The stream.

Save(string)

Saves the session state to the specified file.

void Save(string filePath)

Parameters

filePath string

The file path.

Examples

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");
                                                                                                                                                         }
                                                                                                                                                     }
                                                                                                                                                 }
                                                                                                                                             }

## See Also

[IDisposable](https://learn.microsoft.com/dotnet/api/system.idisposable)