Interface IMaskingSession

Interface IMaskingSession

Το όνομα: Aspose.Imaging.Masking Συγκέντρωση: Aspose.Imaging.dll (25.4.0)

Η συνεδρίαση μάσκας

public interface IMaskingSession : IDisposable

Implements

IDisposable

Examples

Αποθηκεύστε τη συνεδρία σε ένα αρχείο για μεγάλες συνεδρίες, καθώς και για τη δυνατότητα επανεξέτασης της συνεδρίας σε άλλο περιβάλλον.

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

Decompose()

Πρώτη σκληρή λειτουργία αποσύνθεσης

MaskingResult Decompose()

Returns

MaskingResult

Το αποτέλεσμα της λειτουργίας μάσκας ως σειρά από παρόχους εικόνας τμήματος.

Examples

Αποθηκεύστε τη συνεδρία σε ένα αρχείο για μεγάλες συνεδρίες, καθώς και για τη δυνατότητα επανεξέτασης της συνεδρίας σε άλλο περιβάλλον.

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

DecomposeAsync()

Δημιουργεί την ασύγχρονη εργασία που μπορεί να εκτελέσει την πρώτη σκληρή λειτουργία αποσύνθεσης

IMaskingAsyncTask DecomposeAsync()

Returns

IMaskingAsyncTask

Η ασύγχρονη αποσύνθεση της εργασίας

ImproveDecomposition(Φωτογραφίες)

Δραστηριότητες για την ανάκαμψη της λειτουργίας

MaskingResult ImproveDecomposition(IMaskingArgs maskingArguments)

Parameters

maskingArguments IMaskingArgs

Τα κρυμμένα επιχειρήματα.

Returns

MaskingResult

Το αποτέλεσμα της λειτουργίας μάσκας ως σειρά από παρόχους εικόνας τμήματος.

Examples

Αποθηκεύστε τη συνεδρία σε ένα αρχείο για μεγάλες συνεδρίες, καθώς και για τη δυνατότητα επανεξέτασης της συνεδρίας σε άλλο περιβάλλον.

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

ImproveDecompositionAsync(Φωτογραφίες)

Δημιουργεί την ασύγχρονη εργασία που μπορεί να εκτελέσει την αναστρέψιμη λειτουργία αποσύνθεσης

IMaskingAsyncTask ImproveDecompositionAsync(IMaskingArgs maskingArguments)

Parameters

maskingArguments IMaskingArgs

Τα κρυμμένα επιχειρήματα.

Returns

IMaskingAsyncTask

Η ασύγχρονη αποσύνθεση της εργασίας

Save(Stream)

Αποθηκεύστε την κατάσταση συνεδρίας στην καθορισμένη ροή.

void Save(Stream stream)

Parameters

stream Stream

Το ρεύμα.

Save(Σύνδεσμος)

Αποθηκεύει την κατάσταση της συνεδρίας στο καθορισμένο αρχείο.

void Save(string filePath)

Parameters

filePath string

Ο δρόμος του αρχείου.

Examples

Αποθηκεύστε τη συνεδρία σε ένα αρχείο για μεγάλες συνεδρίες, καθώς και για τη δυνατότητα επανεξέτασης της συνεδρίας σε άλλο περιβάλλον.

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

Δείτε επίσης

IDisposable

 Ελληνικά