Class MaskingResult

Class MaskingResult

İsim alanı : Aspose.Imaging.Masking.Result Toplantı: Aspose.Imaging.dll (25.4.0)

Temel abstrak sınıf, görüntü maskeleme sisteminden sonuç görüntüsü sağlayabilir.

public abstract class MaskingResult : DisposableObject, IDisposable, IEnumerable<imaskinglayer>, IEnumerable

Inheritance

object DisposableObject MaskingResult

Implements

IDisposable , IEnumerable , IEnumerable

mirasçı üyeleri

DisposableObject.Dispose() , DisposableObject.ReleaseManagedResources() , DisposableObject.ReleaseUnmanagedResources() , DisposableObject.VerifyNotDisposed() , DisposableObject.Disposed , object.GetType() , object.MemberwiseClone() , object.ToString() , object.Equals(object?) , object.Equals(object?, object?) , object.ReferenceEquals(object?, object?) , object.GetHashCode()

Examples

Bu örnek, resim maskeleri ve K-means segmentasyon algoritması kullanılarak bir raster görüntüsünü birden fazla görüntüye nasıl ayırt edeceğinizi gösterir. resim maskeleri, arka planı ön görüntü nesnelerinden ayırmak için kullanılan bir görüntü işleme tekniğidir.

string dir = "c:\\temp\\";

                                                                                                                                                                                                                                                                     using (Aspose.Imaging.RasterImage image = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "Blue hills.png"))
                                                                                                                                                                                                                                                                     {
                                                                                                                                                                                                                                                                         Aspose.Imaging.Masking.Options.AutoMaskingArgs args = new Aspose.Imaging.Masking.Options.AutoMaskingArgs();

                                                                                                                                                                                                                                                                         // Set the number of clusters (separated objects). The default value is 2, the foreground object and the background.
                                                                                                                                                                                                                                                                         args.NumberOfObjects = 3;

                                                                                                                                                                                                                                                                         // Set the maximum number of iterations.
                                                                                                                                                                                                                                                                         args.MaxIterationNumber = 50;

                                                                                                                                                                                                                                                                         // Set the precision of segmentation method (optional)
                                                                                                                                                                                                                                                                         args.Precision = 1;

                                                                                                                                                                                                                                                                         // Each cluster (segment) will be stored to a separate PNG file.
                                                                                                                                                                                                                                                                         Aspose.Imaging.ImageOptions.PngOptions exportOptions = new Aspose.Imaging.ImageOptions.PngOptions();
                                                                                                                                                                                                                                                                         exportOptions.ColorType = Aspose.Imaging.FileFormats.Png.PngColorType.TruecolorWithAlpha;
                                                                                                                                                                                                                                                                         exportOptions.Source = new Aspose.Imaging.Sources.StreamSource(new System.IO.MemoryStream());

                                                                                                                                                                                                                                                                         Aspose.Imaging.Masking.Options.MaskingOptions maskingOptions = new Aspose.Imaging.Masking.Options.MaskingOptions();

                                                                                                                                                                                                                                                                         // Use K-means clustering.
                                                                                                                                                                                                                                                                         // K-means clustering allows to split image into several independent clusters (segments).
                                                                                                                                                                                                                                                                         maskingOptions.Method = Masking.Options.SegmentationMethod.KMeans;
                                                                                                                                                                                                                                                                         maskingOptions.Decompose = true;
                                                                                                                                                                                                                                                                         maskingOptions.Args = args;

                                                                                                                                                                                                                                                                         // The backgroung color will be orange.
                                                                                                                                                                                                                                                                         maskingOptions.BackgroundReplacementColor = Aspose.Imaging.Color.Orange;
                                                                                                                                                                                                                                                                         maskingOptions.ExportOptions = exportOptions;

                                                                                                                                                                                                                                                                         // Create an instance of the ImageMasking class.
                                                                                                                                                                                                                                                                         Aspose.Imaging.Masking.ImageMasking masking = new Aspose.Imaging.Masking.ImageMasking(image);

                                                                                                                                                                                                                                                                         // Divide the source image into several clusters (segments).
                                                                                                                                                                                                                                                                         using (Aspose.Imaging.Masking.Result.MaskingResult maskingResult = masking.Decompose(maskingOptions))
                                                                                                                                                                                                                                                                         {
                                                                                                                                                                                                                                                                             // Obtain images from masking result and save them to PNG.
                                                                                                                                                                                                                                                                             for (int i = 0; i &lt; maskingResult.Length; i++)
                                                                                                                                                                                                                                                                             {
                                                                                                                                                                                                                                                                                 string outputFileName = string.Format("Blue hills.Segment{0}.png", maskingResult[i].ObjectNumber);
                                                                                                                                                                                                                                                                                 using (Aspose.Imaging.Image resultImage = maskingResult[i].GetImage())
                                                                                                                                                                                                                                                                                 {
                                                                                                                                                                                                                                                                                     resultImage.Save(dir + outputFileName);
                                                                                                                                                                                                                                                                                 }
                                                                                                                                                                                                                                                                             }
                                                                                                                                                                                                                                                                         }
                                                                                                                                                                                                                                                                     }

Segmentasyon sürecini hızlandırmak için bir segment maskesi kullanın

// Masking export options
                                                                    Aspose.Imaging.ImageOptions.PngOptions exportOptions = new Aspose.Imaging.ImageOptions.PngOptions();
                                                                    exportOptions.ColorType = Aspose.Imaging.FileFormats.Png.PngColorType.TruecolorWithAlpha;
                                                                    exportOptions.Source = new Aspose.Imaging.Sources.StreamSource(new System.IO.MemoryStream());

                                                                    Aspose.Imaging.Masking.Options.MaskingOptions maskingOptions = new Aspose.Imaging.Masking.Options.MaskingOptions();

                                                                    // Use GraphCut clustering.
                                                                    maskingOptions.Method = Masking.Options.SegmentationMethod.GraphCut;
                                                                    maskingOptions.Decompose = false;
                                                                    maskingOptions.Args = new Aspose.Imaging.Masking.Options.AutoMaskingArgs();

                                                                    // The backgroung color will be transparent.
                                                                    maskingOptions.BackgroundReplacementColor = Aspose.Imaging.Color.Transparent;
                                                                    maskingOptions.ExportOptions = exportOptions;

                                                                    string dir = "c:\\temp\\";
                                                                    using (Aspose.Imaging.RasterImage image = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "BigImage.jpg"))
                                                                    {
                                                                        Aspose.Imaging.Size imageSize = image.Size;

                                                                        // Reducing image size to speed up the segmentation process
                                                                        image.ResizeHeightProportionally(600, Aspose.Imaging.ResizeType.HighQualityResample);

                                                                        // Create an instance of the ImageMasking class.
                                                                        Aspose.Imaging.Masking.ImageMasking masking = new Aspose.Imaging.Masking.ImageMasking(image);

                                                                        // Divide the source image into several clusters (segments).
                                                                        using (Aspose.Imaging.Masking.Result.MaskingResult maskingResult = masking.Decompose(maskingOptions))
                                                                        {
                                                                            // Getting the foreground mask
                                                                            using (Aspose.Imaging.RasterImage foregroundMask = maskingResult[1].GetMask()) 
                                                                            {
                                                                                // Increase the size of the mask to the size of the original image
                                                                                foregroundMask.Resize(imageSize.Width, imageSize.Height, Aspose.Imaging.ResizeType.NearestNeighbourResample);

                                                                                // Applying the mask to the original image to obtain a foreground segment
                                                                                using (Aspose.Imaging.RasterImage originImage = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "BigImage.jpg"))
                                                                                {
                                                                                    Aspose.Imaging.Masking.ImageMasking.ApplyMask(originImage, foregroundMask, maskingOptions);
                                                                                    originImage.Save(dir + "BigImage_foreground.png", exportOptions);
                                                                                }
                                                                            }
                                                                        }
                                                                    }

Bu örnek, resim maskeleri ve manuel bir maske kullanılarak bir raster görüntüsünü birden fazla görüntüye nasıl dağıtacağınızı gösterir. resim maskeleri, arka planı ön görüntü nesnelerinden ayırmak için kullanılan bir görüntü işleme tekniğidir.

string dir = "c:\\temp\\";

                                                                                                                                                                                                                                                // Define a manual mask.
                                                                                                                                                                                                                                                Aspose.Imaging.GraphicsPath manualMask = new Aspose.Imaging.GraphicsPath();
                                                                                                                                                                                                                                                Aspose.Imaging.Figure figure = new Aspose.Imaging.Figure();
                                                                                                                                                                                                                                                figure.AddShape(new Aspose.Imaging.Shapes.EllipseShape(new RectangleF(50, 50, 40, 40)));
                                                                                                                                                                                                                                                figure.AddShape(new Aspose.Imaging.Shapes.RectangleShape(new RectangleF(10, 20, 50, 30)));
                                                                                                                                                                                                                                                manualMask.AddFigure(figure);

                                                                                                                                                                                                                                                // Each cluster (segment) will be stored to a separate PNG file.
                                                                                                                                                                                                                                                Aspose.Imaging.ImageOptions.PngOptions exportOptions = new Aspose.Imaging.ImageOptions.PngOptions();
                                                                                                                                                                                                                                                exportOptions.ColorType = Aspose.Imaging.FileFormats.Png.PngColorType.TruecolorWithAlpha;
                                                                                                                                                                                                                                                exportOptions.Source = new Aspose.Imaging.Sources.StreamSource(new System.IO.MemoryStream());

                                                                                                                                                                                                                                                // Set the manual mask.
                                                                                                                                                                                                                                                Aspose.Imaging.Masking.Options.ManualMaskingArgs args = new Aspose.Imaging.Masking.Options.ManualMaskingArgs();
                                                                                                                                                                                                                                                args.Mask = manualMask;

                                                                                                                                                                                                                                                using (RasterImage image = (RasterImage)Image.Load(dir + "Blue hills.png"))
                                                                                                                                                                                                                                                {
                                                                                                                                                                                                                                                    Aspose.Imaging.Masking.Options.MaskingOptions maskingOptions = new Aspose.Imaging.Masking.Options.MaskingOptions();

                                                                                                                                                                                                                                                    // Use manual clustering algorithm.
                                                                                                                                                                                                                                                    maskingOptions.Method = Masking.Options.SegmentationMethod.Manual;

                                                                                                                                                                                                                                                    // All shapes making up a mask will be combined into one. 
                                                                                                                                                                                                                                                    maskingOptions.Decompose = false;
                                                                                                                                                                                                                                                    maskingOptions.Args = args;

                                                                                                                                                                                                                                                    // The backgroung color will be orange.
                                                                                                                                                                                                                                                    maskingOptions.BackgroundReplacementColor = Aspose.Imaging.Color.Orange;
                                                                                                                                                                                                                                                    maskingOptions.ExportOptions = exportOptions;

                                                                                                                                                                                                                                                    // The area of the source image that masking will be applied to.
                                                                                                                                                                                                                                                    maskingOptions.MaskingArea = new Rectangle(50, 50, 120, 120);

                                                                                                                                                                                                                                                    // Create an instance of the ImageMasking class.
                                                                                                                                                                                                                                                    Aspose.Imaging.Masking.ImageMasking masking = new Aspose.Imaging.Masking.ImageMasking(image);

                                                                                                                                                                                                                                                    // Divide the source image into several clusters (segments).
                                                                                                                                                                                                                                                    using (Aspose.Imaging.Masking.Result.MaskingResult maskingResult = masking.Decompose(maskingOptions))
                                                                                                                                                                                                                                                    {
                                                                                                                                                                                                                                                        // Obtain images from masking result and save them to PNG.
                                                                                                                                                                                                                                                        for (int i = 0; i &lt; maskingResult.Length; i++)
                                                                                                                                                                                                                                                        {
                                                                                                                                                                                                                                                            string outputFileName = string.Format("Blue hills.Segment{0}.png", maskingResult[i].ObjectNumber);
                                                                                                                                                                                                                                                            using (Aspose.Imaging.Image resultImage = maskingResult[i].GetImage())
                                                                                                                                                                                                                                                            {
                                                                                                                                                                                                                                                                resultImage.Save(dir + outputFileName);
                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                }

Bu örnek, segmentasyon (klustrasyon) yönteminin doğruluğunu iyileştirmek için görüntü gizleme algoritması için önerileri nasıl belirleyeceğinizi gösterir. görüntü gizleme, arka planı ön görüntü nesnelerinden ayırmak için kullanılan bir görüntü işleme tekniğidir.

string dir = "c:\\temp\\";

                                                                                                                                                                                                                                                                     using (Aspose.Imaging.RasterImage image = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "Gorilla.bmp"))
                                                                                                                                                                                                                                                                     {
                                                                                                                                                                                                                                                                         Aspose.Imaging.Masking.Options.AutoMaskingArgs args = new Aspose.Imaging.Masking.Options.AutoMaskingArgs();

                                                                                                                                                                                                                                                                         // Suggestion #1.
                                                                                                                                                                                                                                                                         // Analyze the image visually and set the area of interest. The result of segmentation will include only objects that will be completely located within this area.
                                                                                                                                                                                                                                                                         args.ObjectsRectangles = new Rectangle[]
                                                                                                                                                                                                                                                                         {
                                                                                                                                                                                                                                                                             new Rectangle(86, 6, 270, 364),
                                                                                                                                                                                                                                                                         };

                                                                                                                                                                                                                                                                         // Suggestion #2.
                                                                                                                                                                                                                                                                         // Analyze the image visually and set the points that belong to separated objects.
                                                                                                                                                                                                                                                                         args.ObjectsPoints = new Point[][]
                                                                                                                                                                                                                                                                         {
                                                                                                                                                                                                                                                                             new Point[] { new Point(103, 326) },
                                                                                                                                                                                                                                                                             new Point[] { new Point(280, 43) },
                                                                                                                                                                                                                                                                             new Point[] { new Point(319, 86) },
                                                                                                                                                                                                                                                                         };

                                                                                                                                                                                                                                                                         // Each cluster (segment) will be stored to a separate PNG file.
                                                                                                                                                                                                                                                                         Aspose.Imaging.ImageOptions.PngOptions exportOptions = new Aspose.Imaging.ImageOptions.PngOptions();
                                                                                                                                                                                                                                                                         exportOptions.ColorType = Aspose.Imaging.FileFormats.Png.PngColorType.TruecolorWithAlpha;
                                                                                                                                                                                                                                                                         exportOptions.Source = new Aspose.Imaging.Sources.StreamSource(new System.IO.MemoryStream());

                                                                                                                                                                                                                                                                         Aspose.Imaging.Masking.Options.MaskingOptions maskingOptions = new Aspose.Imaging.Masking.Options.MaskingOptions();

                                                                                                                                                                                                                                                                         // Use GraphCut clustering.
                                                                                                                                                                                                                                                                         maskingOptions.Method = Masking.Options.SegmentationMethod.GraphCut;
                                                                                                                                                                                                                                                                         maskingOptions.Decompose = false;
                                                                                                                                                                                                                                                                         maskingOptions.Args = args;

                                                                                                                                                                                                                                                                         // The backgroung color will be orange.
                                                                                                                                                                                                                                                                         maskingOptions.BackgroundReplacementColor = Aspose.Imaging.Color.Orange;
                                                                                                                                                                                                                                                                         maskingOptions.ExportOptions = exportOptions;

                                                                                                                                                                                                                                                                         // Create an instance of the ImageMasking class.
                                                                                                                                                                                                                                                                         Aspose.Imaging.Masking.ImageMasking masking = new Aspose.Imaging.Masking.ImageMasking(image);

                                                                                                                                                                                                                                                                         // Divide the source image into several clusters (segments).
                                                                                                                                                                                                                                                                         using (Aspose.Imaging.Masking.Result.MaskingResult maskingResult = masking.Decompose(maskingOptions))
                                                                                                                                                                                                                                                                         {
                                                                                                                                                                                                                                                                             // Obtain images from masking result and save them to PNG.
                                                                                                                                                                                                                                                                             for (int i = 0; i &lt; maskingResult.Length; i++)
                                                                                                                                                                                                                                                                             {
                                                                                                                                                                                                                                                                                 string outputFileName = string.Format("Gorilla.Segment{0}.png", maskingResult[i].ObjectNumber);
                                                                                                                                                                                                                                                                                 using (Aspose.Imaging.Image resultImage = maskingResult[i].GetImage())
                                                                                                                                                                                                                                                                                 {
                                                                                                                                                                                                                                                                                     resultImage.Save(dir + outputFileName);
                                                                                                                                                                                                                                                                                 }
                                                                                                                                                                                                                                                                             }
                                                                                                                                                                                                                                                                         }
                                                                                                                                                                                                                                                                     }

Maske oturumunu uzun oturumlar için bir dosyaya kaydetmek, aynı zamanda oturumu başka bir ortamda yeniden başlatma olasılığı için.

string dir = "c:\\temp\\";
                                                                                                                                                 string sessionBackupFile = dir + "session.bak";

                                                                                                                                                 // Masking export options
                                                                                                                                                 Aspose.Imaging.ImageOptions.PngOptions exportOptions = new Aspose.Imaging.ImageOptions.PngOptions();
                                                                                                                                                 exportOptions.ColorType = Aspose.Imaging.FileFormats.Png.PngColorType.TruecolorWithAlpha;
                                                                                                                                                 exportOptions.Source = new Aspose.Imaging.Sources.StreamSource(new System.IO.MemoryStream());

                                                                                                                                                 Aspose.Imaging.Masking.Options.MaskingOptions maskingOptions = new Aspose.Imaging.Masking.Options.MaskingOptions();

                                                                                                                                                 // Use GraphCut clustering.
                                                                                                                                                 maskingOptions.Method = Masking.Options.SegmentationMethod.GraphCut;
                                                                                                                                                 maskingOptions.Decompose = false;
                                                                                                                                                 maskingOptions.Args = new Aspose.Imaging.Masking.Options.AutoMaskingArgs();

                                                                                                                                                 // The backgroung color will be orange.
                                                                                                                                                 maskingOptions.BackgroundReplacementColor = Aspose.Imaging.Color.Orange;
                                                                                                                                                 maskingOptions.ExportOptions = exportOptions;

                                                                                                                                                 // Starting a session for the first time and saving to a file
                                                                                                                                                 using (Aspose.Imaging.RasterImage image = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "Gorilla.bmp"))
                                                                                                                                                 {
                                                                                                                                                     // Create an instance of the ImageMasking class.
                                                                                                                                                     Aspose.Imaging.Masking.ImageMasking masking = new Aspose.Imaging.Masking.ImageMasking(image);

                                                                                                                                                     using (Aspose.Imaging.Masking.IMaskingSession session = masking.CreateSession(maskingOptions))
                                                                                                                                                     {
                                                                                                                                                         using (Aspose.Imaging.Masking.Result.MaskingResult maskingResult = session.Decompose())
                                                                                                                                                         {
                                                                                                                                                             using (Aspose.Imaging.RasterImage segmentImage = maskingResult[1].GetImage())
                                                                                                                                                             {
                                                                                                                                                                 segmentImage.Save(dir + "step1.png");
                                                                                                                                                             }
                                                                                                                                                         }

                                                                                                                                                         session.Save(sessionBackupFile);
                                                                                                                                                     }
                                                                                                                                                 }

                                                                                                                                                 // Resuming a masking session from a file
                                                                                                                                                 using (Aspose.Imaging.RasterImage image = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "Gorilla.bmp"))
                                                                                                                                                 {
                                                                                                                                                     // Create an instance of the ImageMasking class.
                                                                                                                                                     Aspose.Imaging.Masking.ImageMasking masking = new Aspose.Imaging.Masking.ImageMasking(image);

                                                                                                                                                     using (Aspose.Imaging.Masking.IMaskingSession session = masking.LoadSession(sessionBackupFile))
                                                                                                                                                     {
                                                                                                                                                         Aspose.Imaging.Masking.Options.AutoMaskingArgs args = new Aspose.Imaging.Masking.Options.AutoMaskingArgs();

                                                                                                                                                         // Analyze the image visually and set the points that belong to separated objects.
                                                                                                                                                         args.ObjectsPoints = new Point[][]
                                                                                                                                                                                      {
                                                                                                                                                                                          new Point[]
                                                                                                                                                                                              {
                                                                                                                                                                                                  new Point(0, 0), new Point(0, 1), new Point(1, 0),
                                                                                                                                                                                                  new Point(1, 1), new Point(2, 0), new Point(2, 1),
                                                                                                                                                                                                  new Point(3, 0), new Point(3, 1)
                                                                                                                                                                                              },
                                                                                                                                                                                      };
                                                                                                                                                         using (Aspose.Imaging.Masking.Result.MaskingResult maskingResult = session.ImproveDecomposition(args))
                                                                                                                                                         {
                                                                                                                                                             // Explicit transfer of export options, since it is not serializable
                                                                                                                                                             maskingResult.MaskingOptions.ExportOptions = exportOptions;

                                                                                                                                                             using (Aspose.Imaging.RasterImage segmentImage = maskingResult[1].GetImage())
                                                                                                                                                             {
                                                                                                                                                                 segmentImage.Save(dir + "step2.png");
                                                                                                                                                             }
                                                                                                                                                         }
                                                                                                                                                     }
                                                                                                                                                 }

Constructors

MaskingResult(MaskingOptions, RasterImage ve Rectangle)

Aspose.Imaging.Masking.Result.MaskingResult sınıfının yeni bir örneği başlatılır.

protected MaskingResult(MaskingOptions maskingOptions, RasterImage originImage, Rectangle maskingArea)

Parameters

maskingOptions MaskingOptions

Maske seçenekleri vardır.

originImage RasterImage

Orijinal görüntü.

maskingArea Rectangle

Maske alanı için.

Fields

MaskingArea

Maske alanı

protected readonly Rectangle MaskingArea

alan değeri

Rectangle

MaskingOptions

Maske seçenekleri

public readonly MaskingOptions MaskingOptions

alan değeri

MaskingOptions

OriginImage

Kaynak Görüntüsü

protected readonly RasterImage OriginImage

alan değeri

RasterImage

Properties

Layers

katmanları alır.

public abstract IMaskingLayer[] Layers { get; }

Mülkiyet Değer

IMaskingLayer […]

Length

Uzunluğu alır.

public int Length { get; }

Mülkiyet Değer

int

Examples

Bu örnek, resim maskeleri ve K-means segmentasyon algoritması kullanılarak bir raster görüntüsünü birden fazla görüntüye nasıl ayırt edeceğinizi gösterir. resim maskeleri, arka planı ön görüntü nesnelerinden ayırmak için kullanılan bir görüntü işleme tekniğidir.

string dir = "c:\\temp\\";

                                                                                                                                                                                                                                                                     using (Aspose.Imaging.RasterImage image = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "Blue hills.png"))
                                                                                                                                                                                                                                                                     {
                                                                                                                                                                                                                                                                         Aspose.Imaging.Masking.Options.AutoMaskingArgs args = new Aspose.Imaging.Masking.Options.AutoMaskingArgs();

                                                                                                                                                                                                                                                                         // Set the number of clusters (separated objects). The default value is 2, the foreground object and the background.
                                                                                                                                                                                                                                                                         args.NumberOfObjects = 3;

                                                                                                                                                                                                                                                                         // Set the maximum number of iterations.
                                                                                                                                                                                                                                                                         args.MaxIterationNumber = 50;

                                                                                                                                                                                                                                                                         // Set the precision of segmentation method (optional)
                                                                                                                                                                                                                                                                         args.Precision = 1;

                                                                                                                                                                                                                                                                         // Each cluster (segment) will be stored to a separate PNG file.
                                                                                                                                                                                                                                                                         Aspose.Imaging.ImageOptions.PngOptions exportOptions = new Aspose.Imaging.ImageOptions.PngOptions();
                                                                                                                                                                                                                                                                         exportOptions.ColorType = Aspose.Imaging.FileFormats.Png.PngColorType.TruecolorWithAlpha;
                                                                                                                                                                                                                                                                         exportOptions.Source = new Aspose.Imaging.Sources.StreamSource(new System.IO.MemoryStream());

                                                                                                                                                                                                                                                                         Aspose.Imaging.Masking.Options.MaskingOptions maskingOptions = new Aspose.Imaging.Masking.Options.MaskingOptions();

                                                                                                                                                                                                                                                                         // Use K-means clustering.
                                                                                                                                                                                                                                                                         // K-means clustering allows to split image into several independent clusters (segments).
                                                                                                                                                                                                                                                                         maskingOptions.Method = Masking.Options.SegmentationMethod.KMeans;
                                                                                                                                                                                                                                                                         maskingOptions.Decompose = true;
                                                                                                                                                                                                                                                                         maskingOptions.Args = args;

                                                                                                                                                                                                                                                                         // The backgroung color will be orange.
                                                                                                                                                                                                                                                                         maskingOptions.BackgroundReplacementColor = Aspose.Imaging.Color.Orange;
                                                                                                                                                                                                                                                                         maskingOptions.ExportOptions = exportOptions;

                                                                                                                                                                                                                                                                         // Create an instance of the ImageMasking class.
                                                                                                                                                                                                                                                                         Aspose.Imaging.Masking.ImageMasking masking = new Aspose.Imaging.Masking.ImageMasking(image);

                                                                                                                                                                                                                                                                         // Divide the source image into several clusters (segments).
                                                                                                                                                                                                                                                                         using (Aspose.Imaging.Masking.Result.MaskingResult maskingResult = masking.Decompose(maskingOptions))
                                                                                                                                                                                                                                                                         {
                                                                                                                                                                                                                                                                             // Obtain images from masking result and save them to PNG.
                                                                                                                                                                                                                                                                             for (int i = 0; i &lt; maskingResult.Length; i++)
                                                                                                                                                                                                                                                                             {
                                                                                                                                                                                                                                                                                 string outputFileName = string.Format("Blue hills.Segment{0}.png", maskingResult[i].ObjectNumber);
                                                                                                                                                                                                                                                                                 using (Aspose.Imaging.Image resultImage = maskingResult[i].GetImage())
                                                                                                                                                                                                                                                                                 {
                                                                                                                                                                                                                                                                                     resultImage.Save(dir + outputFileName);
                                                                                                                                                                                                                                                                                 }
                                                                                                                                                                                                                                                                             }
                                                                                                                                                                                                                                                                         }
                                                                                                                                                                                                                                                                     }

Bu örnek, resim maskeleri ve manuel bir maske kullanılarak bir raster görüntüsünü birden fazla görüntüye nasıl dağıtacağınızı gösterir. resim maskeleri, arka planı ön görüntü nesnelerinden ayırmak için kullanılan bir görüntü işleme tekniğidir.

string dir = "c:\\temp\\";

                                                                                                                                                                                                                                                // Define a manual mask.
                                                                                                                                                                                                                                                Aspose.Imaging.GraphicsPath manualMask = new Aspose.Imaging.GraphicsPath();
                                                                                                                                                                                                                                                Aspose.Imaging.Figure figure = new Aspose.Imaging.Figure();
                                                                                                                                                                                                                                                figure.AddShape(new Aspose.Imaging.Shapes.EllipseShape(new RectangleF(50, 50, 40, 40)));
                                                                                                                                                                                                                                                figure.AddShape(new Aspose.Imaging.Shapes.RectangleShape(new RectangleF(10, 20, 50, 30)));
                                                                                                                                                                                                                                                manualMask.AddFigure(figure);

                                                                                                                                                                                                                                                // Each cluster (segment) will be stored to a separate PNG file.
                                                                                                                                                                                                                                                Aspose.Imaging.ImageOptions.PngOptions exportOptions = new Aspose.Imaging.ImageOptions.PngOptions();
                                                                                                                                                                                                                                                exportOptions.ColorType = Aspose.Imaging.FileFormats.Png.PngColorType.TruecolorWithAlpha;
                                                                                                                                                                                                                                                exportOptions.Source = new Aspose.Imaging.Sources.StreamSource(new System.IO.MemoryStream());

                                                                                                                                                                                                                                                // Set the manual mask.
                                                                                                                                                                                                                                                Aspose.Imaging.Masking.Options.ManualMaskingArgs args = new Aspose.Imaging.Masking.Options.ManualMaskingArgs();
                                                                                                                                                                                                                                                args.Mask = manualMask;

                                                                                                                                                                                                                                                using (RasterImage image = (RasterImage)Image.Load(dir + "Blue hills.png"))
                                                                                                                                                                                                                                                {
                                                                                                                                                                                                                                                    Aspose.Imaging.Masking.Options.MaskingOptions maskingOptions = new Aspose.Imaging.Masking.Options.MaskingOptions();

                                                                                                                                                                                                                                                    // Use manual clustering algorithm.
                                                                                                                                                                                                                                                    maskingOptions.Method = Masking.Options.SegmentationMethod.Manual;

                                                                                                                                                                                                                                                    // All shapes making up a mask will be combined into one. 
                                                                                                                                                                                                                                                    maskingOptions.Decompose = false;
                                                                                                                                                                                                                                                    maskingOptions.Args = args;

                                                                                                                                                                                                                                                    // The backgroung color will be orange.
                                                                                                                                                                                                                                                    maskingOptions.BackgroundReplacementColor = Aspose.Imaging.Color.Orange;
                                                                                                                                                                                                                                                    maskingOptions.ExportOptions = exportOptions;

                                                                                                                                                                                                                                                    // The area of the source image that masking will be applied to.
                                                                                                                                                                                                                                                    maskingOptions.MaskingArea = new Rectangle(50, 50, 120, 120);

                                                                                                                                                                                                                                                    // Create an instance of the ImageMasking class.
                                                                                                                                                                                                                                                    Aspose.Imaging.Masking.ImageMasking masking = new Aspose.Imaging.Masking.ImageMasking(image);

                                                                                                                                                                                                                                                    // Divide the source image into several clusters (segments).
                                                                                                                                                                                                                                                    using (Aspose.Imaging.Masking.Result.MaskingResult maskingResult = masking.Decompose(maskingOptions))
                                                                                                                                                                                                                                                    {
                                                                                                                                                                                                                                                        // Obtain images from masking result and save them to PNG.
                                                                                                                                                                                                                                                        for (int i = 0; i &lt; maskingResult.Length; i++)
                                                                                                                                                                                                                                                        {
                                                                                                                                                                                                                                                            string outputFileName = string.Format("Blue hills.Segment{0}.png", maskingResult[i].ObjectNumber);
                                                                                                                                                                                                                                                            using (Aspose.Imaging.Image resultImage = maskingResult[i].GetImage())
                                                                                                                                                                                                                                                            {
                                                                                                                                                                                                                                                                resultImage.Save(dir + outputFileName);
                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                }

Bu örnek, segmentasyon (klustrasyon) yönteminin doğruluğunu iyileştirmek için görüntü gizleme algoritması için önerileri nasıl belirleyeceğinizi gösterir. görüntü gizleme, arka planı ön görüntü nesnelerinden ayırmak için kullanılan bir görüntü işleme tekniğidir.

string dir = "c:\\temp\\";

                                                                                                                                                                                                                                                                     using (Aspose.Imaging.RasterImage image = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "Gorilla.bmp"))
                                                                                                                                                                                                                                                                     {
                                                                                                                                                                                                                                                                         Aspose.Imaging.Masking.Options.AutoMaskingArgs args = new Aspose.Imaging.Masking.Options.AutoMaskingArgs();

                                                                                                                                                                                                                                                                         // Suggestion #1.
                                                                                                                                                                                                                                                                         // Analyze the image visually and set the area of interest. The result of segmentation will include only objects that will be completely located within this area.
                                                                                                                                                                                                                                                                         args.ObjectsRectangles = new Rectangle[]
                                                                                                                                                                                                                                                                         {
                                                                                                                                                                                                                                                                             new Rectangle(86, 6, 270, 364),
                                                                                                                                                                                                                                                                         };

                                                                                                                                                                                                                                                                         // Suggestion #2.
                                                                                                                                                                                                                                                                         // Analyze the image visually and set the points that belong to separated objects.
                                                                                                                                                                                                                                                                         args.ObjectsPoints = new Point[][]
                                                                                                                                                                                                                                                                         {
                                                                                                                                                                                                                                                                             new Point[] { new Point(103, 326) },
                                                                                                                                                                                                                                                                             new Point[] { new Point(280, 43) },
                                                                                                                                                                                                                                                                             new Point[] { new Point(319, 86) },
                                                                                                                                                                                                                                                                         };

                                                                                                                                                                                                                                                                         // Each cluster (segment) will be stored to a separate PNG file.
                                                                                                                                                                                                                                                                         Aspose.Imaging.ImageOptions.PngOptions exportOptions = new Aspose.Imaging.ImageOptions.PngOptions();
                                                                                                                                                                                                                                                                         exportOptions.ColorType = Aspose.Imaging.FileFormats.Png.PngColorType.TruecolorWithAlpha;
                                                                                                                                                                                                                                                                         exportOptions.Source = new Aspose.Imaging.Sources.StreamSource(new System.IO.MemoryStream());

                                                                                                                                                                                                                                                                         Aspose.Imaging.Masking.Options.MaskingOptions maskingOptions = new Aspose.Imaging.Masking.Options.MaskingOptions();

                                                                                                                                                                                                                                                                         // Use GraphCut clustering.
                                                                                                                                                                                                                                                                         maskingOptions.Method = Masking.Options.SegmentationMethod.GraphCut;
                                                                                                                                                                                                                                                                         maskingOptions.Decompose = false;
                                                                                                                                                                                                                                                                         maskingOptions.Args = args;

                                                                                                                                                                                                                                                                         // The backgroung color will be orange.
                                                                                                                                                                                                                                                                         maskingOptions.BackgroundReplacementColor = Aspose.Imaging.Color.Orange;
                                                                                                                                                                                                                                                                         maskingOptions.ExportOptions = exportOptions;

                                                                                                                                                                                                                                                                         // Create an instance of the ImageMasking class.
                                                                                                                                                                                                                                                                         Aspose.Imaging.Masking.ImageMasking masking = new Aspose.Imaging.Masking.ImageMasking(image);

                                                                                                                                                                                                                                                                         // Divide the source image into several clusters (segments).
                                                                                                                                                                                                                                                                         using (Aspose.Imaging.Masking.Result.MaskingResult maskingResult = masking.Decompose(maskingOptions))
                                                                                                                                                                                                                                                                         {
                                                                                                                                                                                                                                                                             // Obtain images from masking result and save them to PNG.
                                                                                                                                                                                                                                                                             for (int i = 0; i &lt; maskingResult.Length; i++)
                                                                                                                                                                                                                                                                             {
                                                                                                                                                                                                                                                                                 string outputFileName = string.Format("Gorilla.Segment{0}.png", maskingResult[i].ObjectNumber);
                                                                                                                                                                                                                                                                                 using (Aspose.Imaging.Image resultImage = maskingResult[i].GetImage())
                                                                                                                                                                                                                                                                                 {
                                                                                                                                                                                                                                                                                     resultImage.Save(dir + outputFileName);
                                                                                                                                                                                                                                                                                 }
                                                                                                                                                                                                                                                                             }
                                                                                                                                                                                                                                                                         }
                                                                                                                                                                                                                                                                     }

bu[int ile]

Aspose.Imaging.Masking.Result.IMaskingLayer’ı belirlenen endekste alır.

public IMaskingLayer this[int index] { get; }

Mülkiyet Değer

IMaskingLayer

Methods

GetEnumerator()

Enumerator alın.

public IEnumerator<imaskinglayer> GetEnumerator()

Returns

IEnumerator &lt için; IMaskingLayer >

Bu enumerator.

Ayrıca bakın

DisposableObject

 Türkçe