Class ImageMasking

Class ImageMasking

이름 공간 : Aspose.Imaging.Masking 모임: Aspose.Imaging.dll (25.4.0)

이미지 마스크 작업을 제공합니다.

public class ImageMasking

Inheritance

object ImageMasking

상속 회원들

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

Examples

세그먼트 마스크를 사용하여 세그먼트 과정을 가속화합니다.

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

긴 세션을 위해 파일에 마스크 세션을 저장하고 다른 환경에서 세션을 재개 할 수있는 가능성을 위해.

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

ImageMasking(RasterImage)

Aspose.Imaging.Masking.ImageMasking 클래스의 새로운 사례를 시작합니다.

public ImageMasking(RasterImage sourceImage)

Parameters

sourceImage RasterImage

출처 이미지 입니다.

Examples

이 예제는 이미지 마스크와 K-means 분할 알고리즘을 사용하여 여러 이미지로 레이저 이미지를 분해하는 방법을 보여줍니다.

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

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

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

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

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

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

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

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

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

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

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

세그먼트 마스크를 사용하여 세그먼트 과정을 가속화합니다.

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

이 예제는 이미지 마스크와 수동 마스크를 사용하여 여러 이미지를 분해하는 방법을 보여줍니다. 이미지 마스크는 앞면 이미지 개체에서 배경을 분할하는 데 사용되는 이미지 처리 기술입니다.

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

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

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

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

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

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

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

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

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

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

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

이 예제는 이미지 마스크 알고리즘에 대한 제안을 지정하는 방법을 보여줍니다 분할 (클러스터) 방법의 정확도를 향상시키기 위해. 이미지 마스크는 앞면 이미지 개체에서 배경을 분리하는 데 사용되는 이미지 처리 기술입니다.

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

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

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

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

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

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

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

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

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

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

긴 세션을 위해 파일에 마스크 세션을 저장하고 다른 환경에서 세션을 재개 할 수있는 가능성을 위해.

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

Exceptions

ArgumentNullException

출처 이미지는 0입니다.

Methods

ApplyMask(RasterImage, RasterImage, 마스크 옵션)

마스크를 지정된 출처 이미지에 적용합니다.

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

Parameters

targetImage RasterImage

목표 이미지 입니다.

mask RasterImage

마스크 이미지가 적용됩니다.

maskingOptions MaskingOptions

마스크 옵션

Examples

세그먼트 마스크를 사용하여 세그먼트 과정을 가속화합니다.

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

CreateSession(MaskingOptions)

탈퇴 작업을 수행 할 수있는 마스크 세션을 만듭니다.

public IMaskingSession CreateSession(MaskingOptions options)

Parameters

options MaskingOptions

그 옵션들

Returns

IMaskingSession

마스크 세션은 재조정 분해 작업을 수행 할 수 있습니다.

Examples

긴 세션을 위해 파일에 마스크 세션을 저장하고 다른 환경에서 세션을 재개 할 수있는 가능성을 위해.

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

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

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

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

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

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

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

                                                                                                                                                         session.Save(sessionBackupFile);
                                                                                                                                                     }
                                                                                                                                                 }

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

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

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

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

Decompose(MaskingOptions)

특정 마스크 옵션을 사용하여 분해 작업을 수행합니다.

public MaskingResult Decompose(MaskingOptions options)

Parameters

options MaskingOptions

마스크 옵션

Returns

MaskingResult

마스크 작업의 결과는 세그먼트 이미지 공급 업체의 범위입니다.

Examples

이 예제는 이미지 마스크와 K-means 분할 알고리즘을 사용하여 여러 이미지로 레이저 이미지를 분해하는 방법을 보여줍니다.

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

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

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

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

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

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

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

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

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

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

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

세그먼트 마스크를 사용하여 세그먼트 과정을 가속화합니다.

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

이 예제는 이미지 마스크와 수동 마스크를 사용하여 여러 이미지를 분해하는 방법을 보여줍니다. 이미지 마스크는 앞면 이미지 개체에서 배경을 분할하는 데 사용되는 이미지 처리 기술입니다.

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

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

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

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

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

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

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

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

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

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

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

이 예제는 이미지 마스크 알고리즘에 대한 제안을 지정하는 방법을 보여줍니다 분할 (클러스터) 방법의 정확도를 향상시키기 위해. 이미지 마스크는 앞면 이미지 개체에서 배경을 분리하는 데 사용되는 이미지 처리 기술입니다.

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

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

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

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

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

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

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

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

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

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

DecomposeAsync(MaskingOptions)

특정 마스크 옵션을 사용하여 비동기 분해 작업을 만듭니다.

public IMaskingAsyncTask DecomposeAsync(MaskingOptions options)

Parameters

options MaskingOptions

마스크 옵션

Returns

IMaskingAsyncTask

Asynchronous 분해 작업

LoadSession(Stream)

세션을 지정된 스트림에서 업로드합니다.

public IMaskingSession LoadSession(Stream stream)

Parameters

stream Stream

그 흐름을

Returns

IMaskingSession

마스크 세션은 재조정 분해 작업을 수행 할 수 있습니다.

LoadSession(스트리트)

세션을 지정된 파일에서 다운로드합니다.

public IMaskingSession LoadSession(string filePath)

Parameters

filePath string

파일 경로 입니다.

Returns

IMaskingSession

마스크 세션은 재조정 분해 작업을 수행 할 수 있습니다.

Examples

긴 세션을 위해 파일에 마스크 세션을 저장하고 다른 환경에서 세션을 재개 할 수있는 가능성을 위해.

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

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

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

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

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

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

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

                                                                                                                                                         session.Save(sessionBackupFile);
                                                                                                                                                     }
                                                                                                                                                 }

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

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

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

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