Class ImageMask

Class ImageMask

Numele spaţiului: Aspose.Imaging.MagicWand.ImageMasks Asamblare: Aspose.Imaging.dll (25.4.0)

Descrie o mască de imagine binară.

public abstract class ImageMask : IImageMask, ICloneable

Inheritance

object ImageMask

Derived

CircleMask , EmptyImageMask , ImageBitMask , RectangleMask

Implements

IImageMask , ICloneable

Membrii moștenitori

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

Examples

Exemplul arată cum să alegeți o zonă complicată a unei imagini folosind instrumentul Magic Wand și capacitatea de a interacționa cu măști (invert, union, substrate).

var imageFilePath = "input.png"; 
                                                                                                                                                                  using (RasterImage image = (RasterImage)Image.Load(inputFilePath))
                                                                                                                                                                  {
                                                                                                                                                                      // Create a new mask using magic wand tool based on tone and color of pixel (845, 128)
                                                                                                                                                                      MagicWandTool.Select(image, new MagicWandSettings(845, 128))
                                                                                                                                                                          // Union the existing mask with the specified one created by magic wand tool
                                                                                                                                                                          .Union(new MagicWandSettings(416, 387))
                                                                                                                                                                          // Invert the existing mask
                                                                                                                                                                          .Invert()
                                                                                                                                                                          // Subtract the specified mask created by magic wand tool with specified threshold from the existing one 
                                                                                                                                                                          .Subtract(new MagicWandSettings(1482, 346) { Threshold = 69 })
                                                                                                                                                                          // Subtract four specified rectangle masks from the existing mask one by one
                                                                                                                                                                          .Subtract(new RectangleMask(0, 0, 800, 150))
                                                                                                                                                                          .Subtract(new RectangleMask(0, 380, 600, 220))
                                                                                                                                                                          .Subtract(new RectangleMask(930, 520, 110, 40))
                                                                                                                                                                          .Subtract(new RectangleMask(1370, 400, 120, 200))
                                                                                                                                                                          // Feather mask with specified settings
                                                                                                                                                                          .GetFeathered(new FeatheringSettings() { Size = 3 })
                                                                                                                                                                          // Apply mask to the image
                                                                                                                                                                          .Apply();

                                                                                                                                                                      // Save image
                                                                                                                                                                      image.Save(outputFilePath);
                                                                                                                                                                  }

Constructors

ImageMask(int, int)

Inițializează o nouă instanță a clasei Aspose.Imaging.MagicWand.ImageMasks. ImageMask cu lățimea și înălțimi specificate.

protected ImageMask(int width, int height)

Parameters

width int

Lungimea mască.

height int

Înălțimea mască.

Properties

Bounds

Obțineți limitele, în pixeli, ale acestei măști.

public Rectangle Bounds { get; }

Valoarea proprietății

Rectangle

Height

Obține înălțimea, în pixeli, a acestei măști.

public int Height { get; protected set; }

Valoarea proprietății

int

SelectionBounds

Obține limitele părții selectate a mascăi, în pixeli.

public abstract Rectangle SelectionBounds { get; }

Valoarea proprietății

Rectangle

Source

Obțineți imaginea de sursă utilizată pentru a crea această mască, dacă există.

public RasterImage Source { get; protected set; }

Valoarea proprietății

RasterImage

Width

Obțineți lățimea, în pixeli, a acestei măști.

public int Width { get; protected set; }

Valoarea proprietății

int

Această[int, int]

Obține opacitatea pixelului specificat.

public abstract bool this[int x, int y] { get; }

Valoarea proprietății

bool

Methods

Apply()

Aplicați masca actuală la sursa Aspose.Imaging.RasterImage, dacă există.

public void Apply()

Examples

Exemplul arată cum să alegeți o zonă simplă a unei imagini pe baza tonului și culorii oricărui pixel folosind instrumentul Magic Wand.

var imageFilePath = "input.png"; 
                                                                                                                                using (RasterImage image = (RasterImage)Image.Load(inputFilePath))
                                                                                                                                {
                                                                                                                                    // Create a new mask using magic wand tool based on tone and color of pixel (120, 100) with custom threshold equal to 150
                                                                                                                                    MagicWandTool
                                                                                                                                        .Select(image, new MagicWandSettings(120, 100) { Threshold = 150 })
                                                                                                                                        // Apply mask to the image
                                                                                                                                        .Apply();

                                                                                                                                    // Save image with forced transparency color type option
                                                                                                                                    image.Save(outputFilePath, new ImageOptions.PngOptions()
                                                                                                                                    {
                                                                                                                                        ColorType = PngColorType.TruecolorWithAlpha
                                                                                                                                    });
                                                                                                                                }

Exceptions

NullReferenceException

Se întoarce atunci când imaginea sursă nu este definită.

ApplyTo(RasterImage)

Aplicați masca actuală la Aspose.Imaging.RasterImage specificat.

public void ApplyTo(RasterImage image)

Parameters

image RasterImage

Imaginea pentru a aplica masca la.

Exceptions

ArgumentNullException

Se întinde atunci când imaginea nu este definită.

Clone()

Creează un nou obiect care este o copie a instantei actuale.

public abstract object Clone()

Returns

object

Un nou obiect care este o copie a acestei instante.

Crop(Size)

Masca cu dimensiunea specificata.

public ImageMask Crop(Size size)

Parameters

size Size

Dimensiunea specificată.

Returns

ImageMask

O mască de imagini.

Crop(int, int)

Masca cu amploare și înălțime specificate.

public ImageMask Crop(int width, int height)

Parameters

width int

amplitudinea specificată.

height int

înălţimea specificată.

Returns

ImageMask

O mască de imagini.

Crop(Rectangle)

Masca cu rectangolul specificat.

public abstract ImageMask Crop(Rectangle rectangle)

Parameters

rectangle Rectangle

rectangul specificat.

Returns

ImageMask

O mască de imagini.

ExclusiveDisjunction(ImageMask)

Obține dispunerea exclusivă a mascăi curente cu furnizat.

public ImageBitMask ExclusiveDisjunction(ImageMask mask)

Parameters

mask ImageMask

Masca furnizată

Returns

ImageBitMask

Nou Aspose.Imaging.MagicWand.ImageMasks.ImagicBitMask.

ExclusiveDisjunction(MagicWandSettings)

Obține dispunerea exclusivă a mascăi curente cu rezultatul selecției magice de vânătoare aplicate sursei mascei.

public ImageBitMask ExclusiveDisjunction(MagicWandSettings settings)

Parameters

settings MagicWandSettings

Instalări Magic Wand.

Returns

ImageBitMask

Nou Aspose.Imaging.MagicWand.ImageMasks.ImagicBitMask.

Exceptions

ArgumentNullException

Se toarnă atunci când imaginea sursă nu este definită în mască.

ExclusiveDisjunction(Articole cu eticheta MagicWandSettings)

Obține dispunerea exclusivă a mascăi curente cu rezultatul selecției magice a cuptorului aplicate imaginii furnizate.

public ImageBitMask ExclusiveDisjunction(RasterImage image, MagicWandSettings settings)

Parameters

image RasterImage

Imaginea pentru Magic Wand.

settings MagicWandSettings

Instalări Magic Wand.

Returns

ImageBitMask

Nou Aspose.Imaging.MagicWand.ImageMasks.ImagicBitMask.

GetByteOpacity(int, int)

Obține opacitatea pixelului specificat cu precizie byte.

public byte GetByteOpacity(int x, int y)

Parameters

x int

Coordonatul X al pixelului.

y int

Coordonatul y al pixelului.

Returns

byte

Valoarea byte, reprezentând opacitatea pixelului specificat.

GetFeathered(FeatheringSettings)

Obține o mască grayscale cu granița încărcată cu setările specificate.

public ImageGrayscaleMask GetFeathered(FeatheringSettings settings = null)

Parameters

settings FeatheringSettings

Întâlnirea cu setări.

Returns

ImageGrayscaleMask

Aspose.Imaging.MagicWand.ImageMasks.ImagicGrayscaleMask cu graniță îngustă.

Inflate(int)

Inflă această mască cu cantitatea specificată.

public abstract ImageMask Inflate(int size)

Parameters

size int

Cât de mult ar trebui să plătească această mască?

Returns

ImageMask

O mască de imagini.

Intersect(ImageMask)

Obține intersecția mască curentă cu furnizată.

public ImageBitMask Intersect(ImageMask mask)

Parameters

mask ImageMask

Masca furnizată

Returns

ImageBitMask

Nou Aspose.Imaging.MagicWand.ImageMasks.ImagicBitMask.

Intersect(MagicWandSettings)

Obține intersecția mască curentă cu rezultatul selecției magice a cuptorului aplicat sursei mascii.

public ImageBitMask Intersect(MagicWandSettings settings)

Parameters

settings MagicWandSettings

Instalări Magic Wand.

Returns

ImageBitMask

Nou Aspose.Imaging.MagicWand.ImageMasks.ImagicBitMask.

Exceptions

ArgumentNullException

Se toarnă atunci când imaginea sursă nu este definită în mască.

Intersect(Articole cu eticheta MagicWandSettings)

Obține intersecția mască curentă cu rezultatul selecției magice a cuptorului aplicat imaginii furnizate.

public ImageBitMask Intersect(RasterImage image, MagicWandSettings settings)

Parameters

image RasterImage

Imaginea pentru Magic Wand.

settings MagicWandSettings

Instalări Magic Wand.

Returns

ImageBitMask

Nou Aspose.Imaging.MagicWand.ImageMasks.ImagicBitMask.

Invert()

Obține inversarea mască curentă.

public ImageBitMask Invert()

Returns

ImageBitMask

Nou Aspose.Imaging.MagicWand.ImageMasks.ImagicBitMask.

Examples

Exemplul arată cum să alegeți o zonă complicată a unei imagini folosind instrumentul Magic Wand și capacitatea de a interacționa cu măști (invert, union, substrate).

var imageFilePath = "input.png"; 
                                                                                                                                                                  using (RasterImage image = (RasterImage)Image.Load(inputFilePath))
                                                                                                                                                                  {
                                                                                                                                                                      // Create a new mask using magic wand tool based on tone and color of pixel (845, 128)
                                                                                                                                                                      MagicWandTool.Select(image, new MagicWandSettings(845, 128))
                                                                                                                                                                          // Union the existing mask with the specified one created by magic wand tool
                                                                                                                                                                          .Union(new MagicWandSettings(416, 387))
                                                                                                                                                                          // Invert the existing mask
                                                                                                                                                                          .Invert()
                                                                                                                                                                          // Subtract the specified mask created by magic wand tool with specified threshold from the existing one 
                                                                                                                                                                          .Subtract(new MagicWandSettings(1482, 346) { Threshold = 69 })
                                                                                                                                                                          // Subtract four specified rectangle masks from the existing mask one by one
                                                                                                                                                                          .Subtract(new RectangleMask(0, 0, 800, 150))
                                                                                                                                                                          .Subtract(new RectangleMask(0, 380, 600, 220))
                                                                                                                                                                          .Subtract(new RectangleMask(930, 520, 110, 40))
                                                                                                                                                                          .Subtract(new RectangleMask(1370, 400, 120, 200))
                                                                                                                                                                          // Feather mask with specified settings
                                                                                                                                                                          .GetFeathered(new FeatheringSettings() { Size = 3 })
                                                                                                                                                                          // Apply mask to the image
                                                                                                                                                                          .Apply();

                                                                                                                                                                      // Save image
                                                                                                                                                                      image.Save(outputFilePath);
                                                                                                                                                                  }

IsOpaque(int, int)

Verificați dacă pixelul specificat este opac.

public bool IsOpaque(int x, int y)

Parameters

x int

Coordonatul X al pixelului.

y int

Coordonatul y al pixelului.

Returns

bool

adevărat dacă pixelul specificat este opac; altfel, fals.

IsTransparent(int, int)

Verificați dacă pixelul specificat este transparent.

public bool IsTransparent(int x, int y)

Parameters

x int

Coordonatul X al pixelului.

y int

Coordonatul y al pixelului.

Returns

bool

adevărat dacă pixelul specificat este transparent; altfel, fals.

Subtract(ImageMask)

Obține subtrația mască furnizată de la curent.

public ImageBitMask Subtract(ImageMask mask)

Parameters

mask ImageMask

Masca furnizată

Returns

ImageBitMask

Nou Aspose.Imaging.MagicWand.ImageMasks.ImagicBitMask.

Examples

Exemplul arată cum să alegeți o zonă complicată a unei imagini folosind instrumentul Magic Wand și capacitatea de a interacționa cu măști (invert, union, substrate).

var imageFilePath = "input.png"; 
                                                                                                                                                                  using (RasterImage image = (RasterImage)Image.Load(inputFilePath))
                                                                                                                                                                  {
                                                                                                                                                                      // Create a new mask using magic wand tool based on tone and color of pixel (845, 128)
                                                                                                                                                                      MagicWandTool.Select(image, new MagicWandSettings(845, 128))
                                                                                                                                                                          // Union the existing mask with the specified one created by magic wand tool
                                                                                                                                                                          .Union(new MagicWandSettings(416, 387))
                                                                                                                                                                          // Invert the existing mask
                                                                                                                                                                          .Invert()
                                                                                                                                                                          // Subtract the specified mask created by magic wand tool with specified threshold from the existing one 
                                                                                                                                                                          .Subtract(new MagicWandSettings(1482, 346) { Threshold = 69 })
                                                                                                                                                                          // Subtract four specified rectangle masks from the existing mask one by one
                                                                                                                                                                          .Subtract(new RectangleMask(0, 0, 800, 150))
                                                                                                                                                                          .Subtract(new RectangleMask(0, 380, 600, 220))
                                                                                                                                                                          .Subtract(new RectangleMask(930, 520, 110, 40))
                                                                                                                                                                          .Subtract(new RectangleMask(1370, 400, 120, 200))
                                                                                                                                                                          // Feather mask with specified settings
                                                                                                                                                                          .GetFeathered(new FeatheringSettings() { Size = 3 })
                                                                                                                                                                          // Apply mask to the image
                                                                                                                                                                          .Apply();

                                                                                                                                                                      // Save image
                                                                                                                                                                      image.Save(outputFilePath);
                                                                                                                                                                  }

Subtract(MagicWandSettings)

Obține rezultatul selecției magice de vânătoare aplicate la sursa masei curente retrasă din mască.

public ImageBitMask Subtract(MagicWandSettings settings)

Parameters

settings MagicWandSettings

Instalări Magic Wand.

Returns

ImageBitMask

Nou Aspose.Imaging.MagicWand.ImageMasks.ImagicBitMask.

Exceptions

ArgumentNullException

Se toarnă atunci când imaginea sursă nu este definită în mască.

Subtract(Articole cu eticheta MagicWandSettings)

Obține rezultatul selecției magice a wand-ului aplicat imaginii furnizate subtractate din masca curentă.

public ImageBitMask Subtract(RasterImage image, MagicWandSettings settings)

Parameters

image RasterImage

Imaginea pentru Magic Wand.

settings MagicWandSettings

Instalări Magic Wand.

Returns

ImageBitMask

Nou Aspose.Imaging.MagicWand.ImageMasks.ImagicBitMask.

Union(ImageMask)

Obține uniunea mască curentă cu furnizată.

public ImageBitMask Union(ImageMask mask)

Parameters

mask ImageMask

Masca furnizată

Returns

ImageBitMask

Nou Aspose.Imaging.MagicWand.ImageMasks.ImagicBitMask.

Examples

Exemplul arată cum să alegeți o zonă complicată a unei imagini folosind instrumentul Magic Wand și capacitatea de a interacționa cu măști (invert, union, substrate).

var imageFilePath = "input.png"; 
                                                                                                                                                                  using (RasterImage image = (RasterImage)Image.Load(inputFilePath))
                                                                                                                                                                  {
                                                                                                                                                                      // Create a new mask using magic wand tool based on tone and color of pixel (845, 128)
                                                                                                                                                                      MagicWandTool.Select(image, new MagicWandSettings(845, 128))
                                                                                                                                                                          // Union the existing mask with the specified one created by magic wand tool
                                                                                                                                                                          .Union(new MagicWandSettings(416, 387))
                                                                                                                                                                          // Invert the existing mask
                                                                                                                                                                          .Invert()
                                                                                                                                                                          // Subtract the specified mask created by magic wand tool with specified threshold from the existing one 
                                                                                                                                                                          .Subtract(new MagicWandSettings(1482, 346) { Threshold = 69 })
                                                                                                                                                                          // Subtract four specified rectangle masks from the existing mask one by one
                                                                                                                                                                          .Subtract(new RectangleMask(0, 0, 800, 150))
                                                                                                                                                                          .Subtract(new RectangleMask(0, 380, 600, 220))
                                                                                                                                                                          .Subtract(new RectangleMask(930, 520, 110, 40))
                                                                                                                                                                          .Subtract(new RectangleMask(1370, 400, 120, 200))
                                                                                                                                                                          // Feather mask with specified settings
                                                                                                                                                                          .GetFeathered(new FeatheringSettings() { Size = 3 })
                                                                                                                                                                          // Apply mask to the image
                                                                                                                                                                          .Apply();

                                                                                                                                                                      // Save image
                                                                                                                                                                      image.Save(outputFilePath);
                                                                                                                                                                  }

Union(MagicWandSettings)

Obține uniunea mască curentă cu rezultatul selecției magice a cuptorului aplicat sursei mascei.

public ImageBitMask Union(MagicWandSettings settings)

Parameters

settings MagicWandSettings

Instalări Magic Wand.

Returns

ImageBitMask

Nou Aspose.Imaging.MagicWand.ImageMasks.ImagicBitMask.

Exceptions

ArgumentNullException

Se toarnă atunci când imaginea sursă nu este definită în mască.

Union(Articole cu eticheta MagicWandSettings)

Obține uniunea mască curentă cu rezultatul selecției magice a wand-ului aplicat imaginii furnizate.

public ImageBitMask Union(RasterImage image, MagicWandSettings settings)

Parameters

image RasterImage

Imaginea pentru Magic Wand.

settings MagicWandSettings

Instalări Magic Wand.

Returns

ImageBitMask

Nou Aspose.Imaging.MagicWand.ImageMasks.ImagicBitMask.

Operators

Operatorul +(Imaginea, imaginea)

Uniunea a două mască.

public static ImageBitMask operator +(ImageMask a, ImageMask b)

Parameters

a ImageMask

Prima mască

b ImageMask

A doua mască.

Returns

ImageBitMask

Nou Aspose.Imaging.MagicWand.ImageMasks.ImagicBitMask.

Operatorul(Imaginea, imaginea)

Dispunerea exclusivă a două măști.

public static ImageBitMask operator ^(ImageMask a, ImageMask b)

Parameters

a ImageMask

Prima mască

b ImageMask

A doua mască.

Returns

ImageBitMask

Nou Aspose.Imaging.MagicWand.ImageMasks.ImagicBitMask.

Operatorul explicit ImageGrayscaleMask(ImageMask)

Aspose.Imaging.MagicWand.ImageMasks.ImagicGrayscaleMask operator de castare.

public static explicit operator ImageGrayscaleMask(ImageMask mask)

Parameters

mask ImageMask

Valoarea mască.

Returns

ImageGrayscaleMask

Noul Aspose.Imaging.MagicWand.ImageMasks.ImagicGrayscaleMask.

Operatorul !(ImageMask)

Întoarceți masca

public static ImageBitMask operator !(ImageMask a)

Parameters

a ImageMask

Masca trebuie inversată.

Returns

ImageBitMask

Nou Aspose.Imaging.MagicWand.ImageMasks.ImagicBitMask.

Operatorul *(Imaginea, imaginea)

Intersecția a două măști.

public static ImageBitMask operator *(ImageMask a, ImageMask b)

Parameters

a ImageMask

Prima mască

b ImageMask

A doua mască.

Returns

ImageBitMask

Nou Aspose.Imaging.MagicWand.ImageMasks.ImagicBitMask.

Operatorul -(Imaginea, imaginea)

Întoarceți masca de la prima.

public static ImageBitMask operator -(ImageMask a, ImageMask b)

Parameters

a ImageMask

Prima mască

b ImageMask

A doua mască.

Returns

ImageBitMask

Nou Aspose.Imaging.MagicWand.ImageMasks.ImagicBitMask.

 Română